main.js

/*
THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
if you want to view the source, please visit the github repository of this plugin
*/

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/main.ts
var main_exports = {};
__export(main_exports, {
  default: () => CMDSPACELinkEagle
});
module.exports = __toCommonJS(main_exports);
var import_obsidian5 = require("obsidian");

// src/types.ts
var SUPPORTED_IMAGE_EXTENSIONS = [
  "jpg",
  "jpeg",
  "png",
  "gif",
  "webp",
  "bmp",
  "svg",
  "tiff",
  "tif",
  "heic",
  "heif",
  "avif",
  "ico"
];
var SUPPORTED_VIDEO_EXTENSIONS = ["mp4", "mov", "webm", "avi", "mkv"];
var SUPPORTED_DOCUMENT_EXTENSIONS = ["pdf", "psd", "ai", "sketch"];
var DEFAULT_SETTINGS = {
  eagleApiBaseUrl: "http://localhost:41595",
  connectionTimeout: 5e3,
  thumbnailCacheTTL: 36e5,
  autoSyncOnOpen: false,
  tagPrefix: "",
  tagNormalization: "lowercase",
  linkFormat: "markdown",
  insertThumbnail: true,
  thumbnailSize: "medium",
  defaultFolder: "",
  r2WorkerUrl: "",
  r2ApiKey: "",
  r2PublicUrl: "",
  imageDisplayMode: "cloud",
  embedImageInCard: true,
  insertAsEmbed: true,
  imagePasteBehavior: "ask",
  excalidrawIntegration: true,
  excalidrawImportToEagle: true,
  activeCloudProvider: "imghippo",
  searchScope: ["name", "tags"],
  searchFileTypes: [...SUPPORTED_IMAGE_EXTENSIONS],
  cloudProviders: {
    r2: {
      type: "r2",
      enabled: false,
      name: "Cloudflare R2",
      workerUrl: "",
      apiKey: "",
      publicUrl: ""
    },
    s3: {
      type: "s3",
      enabled: false,
      name: "Amazon S3",
      endpoint: "",
      region: "us-east-1",
      bucket: "",
      accessKeyId: "",
      secretAccessKey: "",
      publicUrl: ""
    },
    webdav: {
      type: "webdav",
      enabled: false,
      name: "WebDAV (Synology/NAS)",
      serverUrl: "",
      username: "",
      password: "",
      uploadPath: "/eagle-uploads",
      publicUrl: ""
    },
    imghippo: {
      type: "imghippo",
      enabled: false,
      name: "ImgHippo",
      apiKey: ""
    },
    custom: {
      type: "custom",
      enabled: false,
      name: "Custom Server",
      uploadUrl: "",
      headers: {},
      publicUrl: ""
    }
  },
  enableCrossPlatform: false,
  autoConvertCrossPlatformPaths: false,
  crossPlatformConversionMode: "modify-source",
  computers: []
};

// src/api.ts
var import_obsidian = require("obsidian");
var import_fs = require("fs");
var EagleApiService = class {
  constructor(settings) {
    this.baseUrl = settings.eagleApiBaseUrl;
    this.timeout = settings.connectionTimeout;
    this.r2WorkerUrl = settings.r2WorkerUrl;
    this.r2ApiKey = settings.r2ApiKey;
    this.r2PublicUrl = settings.r2PublicUrl;
  }
  updateSettings(settings) {
    this.baseUrl = settings.eagleApiBaseUrl;
    this.timeout = settings.connectionTimeout;
    this.r2WorkerUrl = settings.r2WorkerUrl;
    this.r2ApiKey = settings.r2ApiKey;
    this.r2PublicUrl = settings.r2PublicUrl;
  }
  async isConnected() {
    try {
      const info = await this.getApplicationInfo();
      return info !== null;
    } catch (e) {
      return false;
    }
  }
  async getApplicationInfo() {
    var _a;
    try {
      const response = await this.get("/api/application/info");
      return (_a = response.data) != null ? _a : null;
    } catch (e) {
      return null;
    }
  }
  async listItems(options) {
    var _a, _b, _c;
    const params = new URLSearchParams();
    if (options == null ? void 0 : options.keyword)
      params.append("keyword", options.keyword);
    if ((_a = options == null ? void 0 : options.tags) == null ? void 0 : _a.length)
      params.append("tags", options.tags.join(","));
    if ((_b = options == null ? void 0 : options.folders) == null ? void 0 : _b.length)
      params.append("folders", options.folders.join(","));
    if (options == null ? void 0 : options.ext)
      params.append("ext", options.ext);
    if (options == null ? void 0 : options.limit)
      params.append("limit", options.limit.toString());
    if (options == null ? void 0 : options.offset)
      params.append("offset", options.offset.toString());
    if (options == null ? void 0 : options.orderBy)
      params.append("orderBy", options.orderBy);
    const queryString = params.toString();
    const endpoint = queryString ? `/api/item/list?${queryString}` : "/api/item/list";
    const response = await this.get(endpoint);
    return (_c = response.data) != null ? _c : [];
  }
  async getItemInfo(id) {
    var _a;
    try {
      const response = await this.get(`/api/item/info?id=${id}`);
      return (_a = response.data) != null ? _a : null;
    } catch (e) {
      return null;
    }
  }
  async getThumbnailPath(id) {
    var _a;
    try {
      const response = await this.get(`/api/item/thumbnail?id=${id}`);
      return (_a = response.data) != null ? _a : null;
    } catch (e) {
      return null;
    }
  }
  async updateItem(id, updates) {
    try {
      const response = await this.post("/api/item/update", {
        id,
        ...updates
      });
      return response.status === "success";
    } catch (e) {
      return false;
    }
  }
  async addFromUrl(options) {
    try {
      const response = await this.post("/api/item/addFromURL", options);
      return response.status === "success";
    } catch (e) {
      return false;
    }
  }
  async addFromPath(options) {
    try {
      const response = await this.post("/api/item/addFromPath", options);
      if (response.status === "success" && response.data) {
        return { success: true, itemId: response.data };
      }
      return { success: false };
    } catch (e) {
      return { success: false };
    }
  }
  async listFolders() {
    var _a;
    try {
      const response = await this.get("/api/folder/list");
      return (_a = response.data) != null ? _a : [];
    } catch (e) {
      return [];
    }
  }
  async getLibraryInfo() {
    var _a;
    try {
      const response = await this.get("/api/library/info");
      return (_a = response.data) != null ? _a : null;
    } catch (e) {
      return null;
    }
  }
  async getLibraryPath() {
    var _a;
    try {
      const response = await (0, import_obsidian.requestUrl)({
        url: `${this.baseUrl}/api/library/info`,
        method: "GET"
      });
      const json = response.json;
      if ((json == null ? void 0 : json.status) === "success" && (json == null ? void 0 : json.data)) {
        const data = json.data;
        if (typeof data.library === "string") {
          return data.library;
        }
        if (typeof ((_a = data.library) == null ? void 0 : _a.path) === "string") {
          return data.library.path;
        }
        if (typeof data.path === "string") {
          return data.path;
        }
      }
      return null;
    } catch (e) {
      console.error("[CMDS Eagle] getLibraryPath error:", e);
      return null;
    }
  }
  async getLibraryName() {
    var _a;
    const path = await this.getLibraryPath();
    if (!path)
      return null;
    const match = path.match(/([^/]+)\.library\/?$/i);
    if (match) {
      return match[1];
    }
    return ((_a = path.split("/").pop()) == null ? void 0 : _a.replace(".library", "")) || null;
  }
  async refreshThumbnail(id) {
    try {
      const response = await this.post("/api/item/refreshThumbnail", { id });
      return response.status === "success";
    } catch (e) {
      return false;
    }
  }
  async testR2Connection() {
    if (!this.r2WorkerUrl || !this.r2ApiKey) {
      return false;
    }
    try {
      const response = await (0, import_obsidian.requestUrl)({
        url: `${this.r2WorkerUrl}/health`,
        method: "GET",
        headers: {
          "Authorization": `Bearer ${this.r2ApiKey}`
        }
      });
      return response.status === 200;
    } catch (e) {
      return false;
    }
  }
  async getOriginalFilePath(item) {
    const thumbnailPath = await this.getThumbnailPath(item.id);
    if (thumbnailPath) {
      console.log("[CMDS Eagle] thumbnailPath:", thumbnailPath);
      const decodedPath = this.safeDecodeUri(thumbnailPath);
      const folderPath = decodedPath.substring(0, decodedPath.lastIndexOf("/"));
      const originalPath = `${folderPath}/${item.name}.${item.ext}`;
      console.log("[CMDS Eagle] originalPath:", originalPath);
      return originalPath;
    }
    const libraryPath = await this.getLibraryPath();
    if (libraryPath && typeof libraryPath === "string") {
      const originalPath = `${libraryPath}/images/${item.id}.info/${item.name}.${item.ext}`;
      console.log("[CMDS Eagle] originalPath (from library):", originalPath);
      return originalPath;
    }
    console.log("[CMDS Eagle] Could not get file path for item:", item.id);
    return null;
  }
  safeDecodeUri(str) {
    try {
      return decodeURIComponent(str);
    } catch (e) {
      return str;
    }
  }
  async uploadToR2(item) {
    if (!this.r2WorkerUrl || !this.r2ApiKey || !this.r2PublicUrl) {
      return { success: false, error: "R2 settings not configured" };
    }
    const existingKey = getR2KeyFromItem(item);
    if (existingKey) {
      return {
        success: true,
        key: existingKey,
        filename: item.name
      };
    }
    try {
      const filePath = await this.getOriginalFilePath(item);
      if (!filePath) {
        return { success: false, error: "Could not get file path from Eagle" };
      }
      let fileBuffer;
      try {
        fileBuffer = await import_fs.promises.readFile(filePath);
      } catch (e) {
        return {
          success: false,
          error: `Could not read file: ${filePath}`
        };
      }
      const mimeType = getMimeType(item.ext);
      const blob = new Blob([fileBuffer], { type: mimeType });
      const filename = `${item.name}.${item.ext}`;
      const formData = new FormData();
      formData.append("file", blob, filename);
      formData.append("filename", filename);
      formData.append("content_type", mimeType);
      formData.append("eagle_id", item.id);
      const response = await window.fetch(`${this.r2WorkerUrl}/upload`, {
        method: "POST",
        headers: {
          "Authorization": `Bearer ${this.r2ApiKey}`
        },
        body: formData
      });
      if (!response.ok) {
        const errorText = await response.text();
        return { success: false, error: `Upload failed (${response.status}): ${errorText}` };
      }
      const result = await response.json();
      const r2Tag = `r2:${result.key}`;
      const newTags = [...item.tags];
      if (!newTags.includes(r2Tag)) {
        newTags.push(r2Tag);
      }
      if (!newTags.includes("r2-cloud")) {
        newTags.push("r2-cloud");
      }
      await this.updateItem(item.id, { tags: newTags });
      return {
        success: true,
        key: result.key,
        filename: result.filename
      };
    } catch (error) {
      return {
        success: false,
        error: error instanceof Error ? error.message : "Unknown error"
      };
    }
  }
  getCloudUrl(item) {
    const key = getR2KeyFromItem(item);
    if (!key || !this.r2PublicUrl) {
      return null;
    }
    return `${this.r2PublicUrl}/${key}`;
  }
  getLocalThumbnailUrl(id) {
    return `${this.baseUrl}/api/item/thumbnail?id=${id}`;
  }
  async get(endpoint) {
    const response = await (0, import_obsidian.requestUrl)({
      url: `${this.baseUrl}${endpoint}`,
      method: "GET",
      headers: {
        "Content-Type": "application/json"
      }
    });
    return response.json;
  }
  async post(endpoint, body) {
    const response = await (0, import_obsidian.requestUrl)({
      url: `${this.baseUrl}${endpoint}`,
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify(body)
    });
    return response.json;
  }
};
function buildEagleItemUrl(itemId) {
  return `eagle://item/${itemId}`;
}
function parseEagleUrl(url) {
  const itemMatch = url.match(/^eagle:\/\/item\/([A-Z0-9]+)$/i);
  if (itemMatch) {
    return { type: "item", id: itemMatch[1] };
  }
  const folderMatch = url.match(/^eagle:\/\/folder\/([A-Z0-9]+)$/i);
  if (folderMatch) {
    return { type: "folder", id: folderMatch[1] };
  }
  return null;
}
function parseEagleLocalhostUrl(url) {
  const match = url.match(/^https?:\/\/localhost:\d+\/item\?id=([A-Z0-9]+)$/i);
  if (match) {
    return match[1];
  }
  return null;
}
function isEagleLocalhostUrl(url) {
  return /^https?:\/\/localhost:\d+\/item\?id=[A-Z0-9]+$/i.test(url);
}
function getR2KeyFromItem(item) {
  const r2Tag = item.tags.find((t) => t.startsWith("r2:"));
  if (r2Tag) {
    return r2Tag.slice(3);
  }
  return null;
}
function hasR2Upload(item) {
  return item.tags.some((t) => t.startsWith("r2:"));
}
var MIME_TYPES = {
  "jpg": "image/jpeg",
  "jpeg": "image/jpeg",
  "png": "image/png",
  "gif": "image/gif",
  "webp": "image/webp",
  "svg": "image/svg+xml",
  "bmp": "image/bmp",
  "ico": "image/x-icon",
  "tiff": "image/tiff",
  "tif": "image/tiff",
  "heic": "image/heic",
  "heif": "image/heif",
  "avif": "image/avif"
};
function getMimeType(ext) {
  return MIME_TYPES[ext.toLowerCase()] || "application/octet-stream";
}

// src/modals.ts
var import_obsidian2 = require("obsidian");
var EagleSearchModal = class extends import_obsidian2.FuzzySuggestModal {
  constructor(app, api, settings) {
    super(app);
    this.allItems = [];
    this.isLoading = false;
    this.filterContainer = null;
    this.libraryNameEl = null;
    this.api = api;
    this.settings = settings;
    this.activeScopes = new Set(settings.searchScope);
    this.activeFileTypes = new Set(settings.searchFileTypes);
    this.setPlaceholder("Search Eagle items...");
    this.setInstructions([
      { command: "\u2191\u2193", purpose: "navigate" },
      { command: "\u21B5", purpose: "insert link" },
      { command: "esc", purpose: "dismiss" }
    ]);
  }
  async onOpen() {
    void super.onOpen();
    this.buildFilterUI();
    await this.loadItems();
  }
  buildFilterUI() {
    const promptEl = this.modalEl.querySelector(".prompt");
    if (!promptEl)
      return;
    this.filterContainer = createDiv({ cls: "cmdspace-eagle-filters" });
    promptEl.insertBefore(this.filterContainer, promptEl.firstChild);
    const headerRow = this.filterContainer.createDiv({ cls: "cmdspace-eagle-filter-header" });
    this.libraryNameEl = headerRow.createSpan({ cls: "cmdspace-eagle-library-name", text: "Loading..." });
    const scopeRow = this.filterContainer.createDiv({ cls: "cmdspace-eagle-filter-row" });
    scopeRow.createSpan({ text: "Search in:", cls: "cmdspace-eagle-filter-label" });
    const scopeButtons = scopeRow.createDiv({ cls: "cmdspace-eagle-filter-buttons" });
    this.createScopeButton(scopeButtons, "name", "Name");
    this.createScopeButton(scopeButtons, "tags", "Tags");
    this.createScopeButton(scopeButtons, "annotation", "Notes");
    this.createScopeButton(scopeButtons, "folders", "Folders");
    const typeRow = this.filterContainer.createDiv({ cls: "cmdspace-eagle-filter-row" });
    typeRow.createSpan({ text: "File types:", cls: "cmdspace-eagle-filter-label" });
    const typeButtons = typeRow.createDiv({ cls: "cmdspace-eagle-filter-buttons" });
    this.createTypeButton(typeButtons, "images", "Images");
    this.createTypeButton(typeButtons, "videos", "Videos");
    this.createTypeButton(typeButtons, "documents", "Docs");
    this.createTypeButton(typeButtons, "all", "All");
  }
  createScopeButton(container, scope, label) {
    const btn = container.createEl("button", {
      text: label,
      cls: `cmdspace-eagle-filter-btn ${this.activeScopes.has(scope) ? "is-active" : ""}`
    });
    btn.addEventListener("click", (e) => {
      e.preventDefault();
      e.stopPropagation();
      if (this.activeScopes.has(scope)) {
        if (this.activeScopes.size > 1) {
          this.activeScopes.delete(scope);
          btn.removeClass("is-active");
        }
      } else {
        this.activeScopes.add(scope);
        btn.addClass("is-active");
      }
      this.inputEl.dispatchEvent(new Event("input"));
    });
  }
  createTypeButton(container, category, label) {
    const isActive = this.isTypeCategoryActive(category);
    const btn = container.createEl("button", {
      text: label,
      cls: `cmdspace-eagle-filter-btn ${isActive ? "is-active" : ""}`
    });
    btn.addEventListener("click", (e) => {
      e.preventDefault();
      e.stopPropagation();
      this.toggleTypeCategory(category);
      this.updateTypeButtonStates(container.parentElement);
      this.inputEl.dispatchEvent(new Event("input"));
    });
  }
  isTypeCategoryActive(category) {
    const extensions = this.getExtensionsForCategory(category);
    return extensions.some((ext) => this.activeFileTypes.has(ext));
  }
  getExtensionsForCategory(category) {
    switch (category) {
      case "images":
        return SUPPORTED_IMAGE_EXTENSIONS;
      case "videos":
        return SUPPORTED_VIDEO_EXTENSIONS;
      case "documents":
        return SUPPORTED_DOCUMENT_EXTENSIONS;
      case "all":
        return [...SUPPORTED_IMAGE_EXTENSIONS, ...SUPPORTED_VIDEO_EXTENSIONS, ...SUPPORTED_DOCUMENT_EXTENSIONS];
    }
  }
  toggleTypeCategory(category) {
    const extensions = this.getExtensionsForCategory(category);
    const isCurrentlyActive = this.isTypeCategoryActive(category);
    if (category === "all") {
      if (isCurrentlyActive) {
        this.activeFileTypes = new Set(SUPPORTED_IMAGE_EXTENSIONS);
      } else {
        this.activeFileTypes = /* @__PURE__ */ new Set([
          ...SUPPORTED_IMAGE_EXTENSIONS,
          ...SUPPORTED_VIDEO_EXTENSIONS,
          ...SUPPORTED_DOCUMENT_EXTENSIONS
        ]);
      }
    } else {
      if (isCurrentlyActive) {
        extensions.forEach((ext) => this.activeFileTypes.delete(ext));
        if (this.activeFileTypes.size === 0) {
          SUPPORTED_IMAGE_EXTENSIONS.forEach((ext) => this.activeFileTypes.add(ext));
        }
      } else {
        extensions.forEach((ext) => this.activeFileTypes.add(ext));
      }
    }
  }
  updateTypeButtonStates(typeRow) {
    const buttons = typeRow.querySelectorAll(".cmdspace-eagle-filter-btn");
    const categories = ["images", "videos", "documents", "all"];
    buttons.forEach((btn, idx) => {
      if (this.isTypeCategoryActive(categories[idx])) {
        btn.addClass("is-active");
      } else {
        btn.removeClass("is-active");
      }
    });
  }
  async loadItems() {
    if (this.isLoading)
      return;
    this.isLoading = true;
    try {
      const connected = await this.api.isConnected();
      if (!connected) {
        new import_obsidian2.Notice("Eagle is not running. Please start Eagle and try again.");
        this.close();
        return;
      }
      const libraryName = await this.api.getLibraryName();
      if (this.libraryNameEl && libraryName) {
        this.libraryNameEl.setText(`\u{1F4DA} ${libraryName}`);
      }
      this.allItems = await this.api.listItems();
      if (this.libraryNameEl) {
        const count = this.allItems.length;
        const libraryText = libraryName ? `\u{1F4DA} ${libraryName}` : "\u{1F4DA} Eagle";
        this.libraryNameEl.setText(`${libraryText} (${count.toLocaleString()} items)`);
      }
      this.inputEl.dispatchEvent(new Event("input"));
    } catch (error) {
      console.error("Failed to load Eagle items:", error);
      new import_obsidian2.Notice("Failed to load Eagle items. Check console for details.");
    } finally {
      this.isLoading = false;
    }
  }
  getItems() {
    return this.allItems.filter(
      (item) => this.activeFileTypes.has(item.ext.toLowerCase())
    );
  }
  getItemText(item) {
    const parts = [];
    if (this.activeScopes.has("name")) {
      parts.push(item.name);
    }
    if (this.activeScopes.has("tags") && item.tags.length > 0) {
      parts.push(item.tags.join(" "));
    }
    if (this.activeScopes.has("annotation") && item.annotation) {
      parts.push(item.annotation);
    }
    if (this.activeScopes.has("folders") && item.folders.length > 0) {
      parts.push(item.folders.join("/"));
    }
    return parts.join(" ") || item.name;
  }
  renderSuggestion(match, el) {
    const item = match.item;
    const container = el.createDiv({ cls: "cmdspace-eagle-suggestion" });
    const infoDiv = container.createDiv({ cls: "cmdspace-eagle-suggestion-info" });
    infoDiv.createDiv({ cls: "cmdspace-eagle-suggestion-name", text: item.name });
    const metaDiv = infoDiv.createDiv({ cls: "cmdspace-eagle-suggestion-meta" });
    metaDiv.createSpan({ text: item.ext.toUpperCase() });
    metaDiv.createSpan({ text: " \u2022 " });
    metaDiv.createSpan({ text: this.formatFileSize(item.size) });
    if (item.width && item.height) {
      metaDiv.createSpan({ text: " \u2022 " });
      metaDiv.createSpan({ text: `${item.width}\xD7${item.height}` });
    }
    if (item.tags.length > 0) {
      const tagsDiv = infoDiv.createDiv({ cls: "cmdspace-eagle-suggestion-tags" });
      item.tags.slice(0, 5).forEach((tag) => {
        tagsDiv.createSpan({ cls: "cmdspace-eagle-tag", text: tag });
      });
      if (item.tags.length > 5) {
        tagsDiv.createSpan({ cls: "cmdspace-eagle-tag-more", text: `+${item.tags.length - 5}` });
      }
    }
  }
  onChooseItem(item, evt) {
    void this.insertItemLink(item);
  }
  async insertItemLink(item) {
    const activeView = this.app.workspace.getActiveViewOfType(import_obsidian2.MarkdownView);
    if (!activeView) {
      new import_obsidian2.Notice("No active markdown editor");
      return;
    }
    const editor = activeView.editor;
    if (this.settings.insertAsEmbed) {
      const filePath = await this.api.getOriginalFilePath(item);
      if (filePath) {
        const fileUrl = this.pathToFileUrl(filePath);
        const filename = `${item.name}.${item.ext}`;
        let output = `![${filename}](${fileUrl})`;
        if (this.settings.insertThumbnail) {
          output += "\n\n" + this.buildMetadataLine(item);
        }
        editor.replaceSelection(output);
        new import_obsidian2.Notice(`Embedded: ${item.name}`);
        return;
      }
    }
    const linkUrl = buildEagleItemUrl(item.id);
    let linkText;
    if (this.settings.linkFormat === "wikilink") {
      linkText = `[[${linkUrl}|${item.name}]]`;
    } else {
      linkText = `[${item.name}](${linkUrl})`;
    }
    if (this.settings.insertThumbnail) {
      const card = this.buildLinkCard(item);
      editor.replaceSelection(card);
    } else {
      editor.replaceSelection(linkText);
    }
    new import_obsidian2.Notice(`Inserted link to: ${item.name}`);
  }
  pathToFileUrl(path) {
    let decodedPath = path;
    try {
      while (decodedPath.includes("%")) {
        const decoded = decodeURIComponent(decodedPath);
        if (decoded === decodedPath)
          break;
        decodedPath = decoded;
      }
    } catch (e) {
      decodedPath = path;
    }
    const convertedPath = this.convertPathForCurrentPlatform(decodedPath);
    const normalizedPath = convertedPath.replace(/\\/g, "/");
    const encodedPath = normalizedPath.split("/").map((segment) => encodeURIComponent(segment)).join("/");
    const platform = process.platform;
    if (platform === "win32" && /^[A-Za-z]:/.test(normalizedPath)) {
      const fixedPath = encodedPath.replace(/^([A-Za-z])%3A/, "$1:");
      return `file:///${fixedPath}`;
    }
    return `file://${encodedPath}`;
  }
  convertPathForCurrentPlatform(path) {
    if (!this.settings.enableCrossPlatform || this.settings.computers.length === 0) {
      return path;
    }
    const sourceComputer = this.findMatchingComputer(path);
    if (!sourceComputer) {
      return path;
    }
    const currentPlatform = process.platform;
    const currentUsername = this.detectCurrentUsername();
    const currentComputer = this.settings.computers.find(
      (c) => c.platform === currentPlatform && c.username === currentUsername
    );
    if (!currentComputer || sourceComputer.id === currentComputer.id) {
      return path;
    }
    let relativePath = "";
    if (sourceComputer.platform === "darwin") {
      relativePath = path.replace(`/Users/${sourceComputer.username}/`, "");
    } else {
      const winPattern = new RegExp(`[A-Za-z]:[/\\\\]Users[/\\\\]${sourceComputer.username}[/\\\\]`, "i");
      relativePath = path.replace(winPattern, "").replace(/\\/g, "/");
    }
    if (currentComputer.platform === "darwin") {
      return `/Users/${currentComputer.username}/${relativePath}`;
    } else {
      return `C:/Users/${currentComputer.username}/${relativePath}`;
    }
  }
  findMatchingComputer(path) {
    for (const computer of this.settings.computers) {
      if (computer.platform === "darwin") {
        if (path.includes(`/Users/${computer.username}/`)) {
          return computer;
        }
      } else if (computer.platform === "win32") {
        const winPattern = new RegExp(`[A-Za-z]:[/\\\\]Users[/\\\\]${computer.username}[/\\\\]`, "i");
        if (winPattern.test(path)) {
          return computer;
        }
      }
    }
    return null;
  }
  detectCurrentUsername() {
    const adapter = this.app.vault.adapter;
    const vaultPath = adapter.basePath || "";
    const platform = process.platform;
    if (platform === "darwin") {
      const match = vaultPath.match(/^\/Users\/([^/]+)/);
      if (match)
        return match[1];
    } else if (platform === "win32") {
      const match = vaultPath.match(/^[A-Za-z]:[/\\]Users[/\\]([^/\\]+)/i);
      if (match)
        return match[1];
    }
    return "";
  }
  buildMetadataLine(item) {
    const linkUrl = buildEagleItemUrl(item.id);
    const tags = item.tags.filter((t) => !t.startsWith("r2:") && t !== "r2-cloud" && t !== "cloud-upload").map((t) => `#${this.normalizeTag(t)}`).join(" ");
    const dimensions = item.width && item.height ? `${item.width}\xD7${item.height}` : "";
    return `> **${item.ext.toUpperCase()}** | ${this.formatFileSize(item.size)}${dimensions ? ` | ${dimensions}` : ""} | ${tags || "No tags"} | [Eagle](${linkUrl})`;
  }
  buildLinkCard(item) {
    const linkUrl = buildEagleItemUrl(item.id);
    const tags = item.tags.map((t) => `#${this.normalizeTag(t)}`).join(" ");
    const dimensions = item.width && item.height ? `${item.width}\xD7${item.height}` : "N/A";
    return `> [!cmdspace-eagle] ${item.name}
> 
> | Property | Value |
> |----------|-------|
> | **Type** | ${item.ext.toUpperCase()} |
> | **Size** | ${this.formatFileSize(item.size)} |
> | **Dimensions** | ${dimensions} |
> | **Tags** | ${tags || "None"} |
> ${item.annotation ? `> **Annotation**: ${item.annotation}
` : ""}
> [Open in Eagle](${linkUrl})

`;
  }
  normalizeTag(tag) {
    let normalized = tag.replace(/\s+/g, "-");
    if (this.settings.tagNormalization === "lowercase") {
      normalized = normalized.toLowerCase();
    }
    if (this.settings.tagPrefix) {
      normalized = `${this.settings.tagPrefix}/${normalized}`;
    }
    return normalized;
  }
  formatFileSize(bytes) {
    if (bytes < 1024)
      return `${bytes} B`;
    if (bytes < 1024 * 1024)
      return `${(bytes / 1024).toFixed(1)} KB`;
    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
  }
};
var ImagePasteChoiceModal = class extends import_obsidian2.Modal {
  constructor(app, cloudProviderName = "Cloud") {
    super(app);
    this.response = { rememberChoice: false };
    this.cloudProviderName = cloudProviderName;
  }
  onOpen() {
    const { contentEl } = this;
    contentEl.empty();
    contentEl.addClass("cmdspace-paste-choice-modal");
    contentEl.createEl("h2", { text: "Where to save image?" });
    const buttonContainer = contentEl.createDiv({ cls: "cmdspace-paste-buttons" });
    const eagleBtn = buttonContainer.createEl("button", {
      text: "Eagle (Local)",
      cls: "mod-cta"
    });
    eagleBtn.addEventListener("click", () => {
      this.response.choice = "eagle";
      this.close();
    });
    const localBtn = buttonContainer.createEl("button", { text: "Vault (Local)" });
    localBtn.addEventListener("click", () => {
      this.response.choice = "local";
      this.close();
    });
    const cloudBtn = buttonContainer.createEl("button", {
      text: `${this.cloudProviderName} (Cloud)`,
      cls: "mod-warning"
    });
    cloudBtn.addEventListener("click", () => {
      this.response.choice = "cloud";
      this.close();
    });
    new import_obsidian2.Setting(contentEl).setName("Remember this choice").setDesc("You can change this later in plugin settings").addToggle((toggle) => {
      toggle.setValue(false).onChange((value) => {
        this.response.rememberChoice = value;
      });
    });
  }
  onClose() {
    var _a, _b;
    if (this.resolvePromise) {
      this.resolvePromise({
        choice: (_a = this.response.choice) != null ? _a : "cancel",
        rememberChoice: (_b = this.response.rememberChoice) != null ? _b : false
      });
    }
  }
  getResponse() {
    return new Promise((resolve) => {
      this.resolvePromise = resolve;
    });
  }
};

// src/settings.ts
var import_obsidian3 = require("obsidian");
var CMDSPACEEagleSettingTab = class extends import_obsidian3.PluginSettingTab {
  constructor(app, plugin) {
    super(app, plugin);
    this.plugin = plugin;
  }
  display() {
    const { containerEl } = this;
    containerEl.empty();
    new import_obsidian3.Setting(containerEl).setName("Connection").setHeading();
    new import_obsidian3.Setting(containerEl).setName("Eagle API Base URL").setDesc("The base URL for Eagle's local API (default: http://localhost:41595)").addText((text) => text.setPlaceholder("http://localhost:41595").setValue(this.plugin.settings.eagleApiBaseUrl).onChange(async (value) => {
      this.plugin.settings.eagleApiBaseUrl = value || "http://localhost:41595";
      await this.plugin.saveSettings();
    }));
    new import_obsidian3.Setting(containerEl).setName("Connection Timeout").setDesc("Timeout in milliseconds for API requests").addText((text) => text.setPlaceholder("5000").setValue(this.plugin.settings.connectionTimeout.toString()).onChange(async (value) => {
      const num = parseInt(value, 10);
      if (!isNaN(num) && num > 0) {
        this.plugin.settings.connectionTimeout = num;
        await this.plugin.saveSettings();
      }
    }));
    new import_obsidian3.Setting(containerEl).setName("Test Connection").setDesc("Check if Eagle is running and accessible").addButton((button) => button.setButtonText("Test").onClick(async () => {
      const api = new EagleApiService(this.plugin.settings);
      const info = await api.getApplicationInfo();
      if (info) {
        new import_obsidian3.Notice(`\u2713 Connected to Eagle ${info.version} (${info.platform})`);
      } else {
        new import_obsidian3.Notice("\u2717 Failed to connect to Eagle. Make sure Eagle is running.");
      }
    }));
    new import_obsidian3.Setting(containerEl).setName("Image paste/drop behavior").setHeading();
    new import_obsidian3.Setting(containerEl).setName("Default image behavior").setDesc("What to do when pasting or dropping images").addDropdown((dropdown) => dropdown.addOption("ask", "Ask every time").addOption("eagle", "Always upload to Eagle (local)").addOption("local", "Always save to vault (local)").addOption("cloud", "Always upload to cloud").setValue(this.plugin.settings.imagePasteBehavior).onChange(async (value) => {
      this.plugin.settings.imagePasteBehavior = value;
      await this.plugin.saveSettings();
    }));
    new import_obsidian3.Setting(containerEl).setName("Excalidraw integration").setHeading();
    new import_obsidian3.Setting(containerEl).setName("Embed images in Excalidraw via cloud").setDesc("When you paste or drop an image onto an Excalidraw canvas, upload it to your cloud provider and embed the URL instead of saving a vault attachment. Eagle assets are resolved to the original; screenshots are uploaded as-is. Requires the Excalidraw plugin and a configured cloud provider.").addToggle((toggle) => toggle.setValue(this.plugin.settings.excalidrawIntegration).onChange(async (value) => {
      this.plugin.settings.excalidrawIntegration = value;
      await this.plugin.saveSettings();
      if (value)
        this.plugin.scanAndAttachExcalidrawContainers();
    }));
    new import_obsidian3.Setting(containerEl).setName("Also add pasted screenshots to Eagle").setDesc("When pasting a clipboard image (not already in Eagle) onto a canvas, also import it into your Eagle library (into the default folder, if set).").addToggle((toggle) => toggle.setValue(this.plugin.settings.excalidrawImportToEagle).onChange(async (value) => {
      this.plugin.settings.excalidrawImportToEagle = value;
      await this.plugin.saveSettings();
    }));
    new import_obsidian3.Setting(containerEl).setName("Search & embed").setHeading();
    new import_obsidian3.Setting(containerEl).setName("Include metadata card").setDesc("Add metadata (type, size, tags, Eagle link) below the image when embedding").addToggle((toggle) => toggle.setValue(this.plugin.settings.insertThumbnail).onChange(async (value) => {
      this.plugin.settings.insertThumbnail = value;
      await this.plugin.saveSettings();
    }));
    this.renderSearchFiltersSettings(containerEl);
    new import_obsidian3.Setting(containerEl).setName("Cloud storage provider").setHeading();
    new import_obsidian3.Setting(containerEl).setName("Active Cloud Provider").setDesc("Select which cloud storage to use for image uploads").addDropdown((dropdown) => dropdown.addOption("r2", "Cloudflare R2").addOption("imghippo", "ImgHippo (Free)").addOption("s3", "Amazon S3").addOption("webdav", "WebDAV (Synology/NAS)").addOption("custom", "Custom Server").setValue(this.plugin.settings.activeCloudProvider).onChange(async (value) => {
      this.plugin.settings.activeCloudProvider = value;
      await this.plugin.saveSettings();
      this.display();
    }));
    this.renderCloudProviderSettings(containerEl);
    new import_obsidian3.Setting(containerEl).setName("Cross-platform sync").setHeading();
    this.renderCrossPlatformSettings(containerEl);
    containerEl.createEl("hr", { attr: { style: "margin: 24px 0; border: none; border-top: 1px solid var(--background-modifier-border);" } });
    const footerEl = containerEl.createEl("div", { attr: { style: "text-align: center; color: var(--text-muted); font-size: 12px;" } });
    footerEl.createEl("div", { text: `CMDS Eagle v${this.plugin.manifest.version}`, attr: { style: "margin-bottom: 8px;" } });
    const linksEl = footerEl.createEl("div");
    linksEl.createSpan({ text: "CMDSPACE " });
    const eduLink = linksEl.createEl("a", { text: "Education", href: "https://class.cmdspace.kr/" });
    eduLink.setAttr("target", "_blank");
    linksEl.createSpan({ text: " \xB7 " });
    const ytLink = linksEl.createEl("a", { text: "YouTube", href: "https://www.youtube.com/@cmdspace" });
    ytLink.setAttr("target", "_blank");
    linksEl.createSpan({ text: " \xB7 " });
    const ghLink = linksEl.createEl("a", { text: "GitHub", href: "https://github.com/johnfkoo951/cmds-eagle" });
    ghLink.setAttr("target", "_blank");
  }
  renderCloudProviderSettings(containerEl) {
    const provider = this.plugin.settings.activeCloudProvider;
    const providerContainer = containerEl.createDiv({ cls: "cloud-provider-settings" });
    switch (provider) {
      case "imghippo":
        this.renderImgHippoSettings(providerContainer);
        break;
      case "r2":
        this.renderR2Settings(providerContainer);
        break;
      case "s3":
        this.renderS3Settings(providerContainer);
        break;
      case "webdav":
        this.renderWebDAVSettings(providerContainer);
        break;
      case "custom":
        this.renderCustomSettings(providerContainer);
        break;
    }
  }
  renderR2Settings(containerEl) {
    new import_obsidian3.Setting(containerEl).setName("Cloudflare R2").setHeading();
    const infoEl = containerEl.createEl("div", { cls: "setting-item-description cmds-eagle-info-block" });
    infoEl.createEl("p", { text: "Cloudflare R2 requires a Worker for uploads. Setup:" });
    const r2List = infoEl.createEl("ol");
    r2List.createEl("li", { text: "Create an R2 bucket in Cloudflare dashboard" });
    r2List.createEl("li", { text: "Deploy the Eagle Cloud Worker (see plugin docs)" });
    r2List.createEl("li", { text: "Copy Worker URL and API Key below" });
    new import_obsidian3.Setting(containerEl).setName("Worker URL").setDesc("Cloudflare Worker URL (must end with .workers.dev)").addText((text) => text.setPlaceholder("https://eagle-uploader.xxx.workers.dev").setValue(this.plugin.settings.cloudProviders.r2.workerUrl).onChange(async (value) => {
      let url = value.trim();
      if (url && !url.startsWith("http")) {
        url = "https://" + url;
      }
      url = url.replace(/\/$/, "");
      this.plugin.settings.cloudProviders.r2.workerUrl = url;
      this.plugin.settings.cloudProviders.r2.enabled = !!(url && this.plugin.settings.cloudProviders.r2.apiKey);
      await this.plugin.saveSettings();
    }));
    new import_obsidian3.Setting(containerEl).setName("API Key").setDesc("API_KEY from Cloudflare Worker Variables").addText((text) => text.setPlaceholder("your-api-key-here").setValue(this.plugin.settings.cloudProviders.r2.apiKey).onChange(async (value) => {
      this.plugin.settings.cloudProviders.r2.apiKey = value.trim();
      this.plugin.settings.cloudProviders.r2.enabled = !!(this.plugin.settings.cloudProviders.r2.workerUrl && value.trim());
      await this.plugin.saveSettings();
    }));
    new import_obsidian3.Setting(containerEl).setName("Public URL").setDesc("R2 bucket public URL (starts with pub-)").addText((text) => text.setPlaceholder("https://pub-xxx.r2.dev").setValue(this.plugin.settings.cloudProviders.r2.publicUrl).onChange(async (value) => {
      this.plugin.settings.cloudProviders.r2.publicUrl = value.trim().replace(/\/$/, "");
      await this.plugin.saveSettings();
    }));
  }
  renderImgHippoSettings(containerEl) {
    new import_obsidian3.Setting(containerEl).setName("ImgHippo (free image hosting)").setHeading();
    const infoEl = containerEl.createEl("div", { cls: "setting-item-description cmds-eagle-info-block" });
    infoEl.createEl("p", { text: "ImgHippo is a free image hosting service. To get your API key:" });
    const ihList = infoEl.createEl("ol");
    const ihLi1 = ihList.createEl("li");
    ihLi1.appendText("Visit ");
    ihLi1.createEl("a", { text: "imghippo.com", href: "https://www.imghippo.com/" });
    ihLi1.appendText(" and sign up/login");
    const ihLi2 = ihList.createEl("li");
    ihLi2.appendText("Go to ");
    ihLi2.createEl("a", { text: "Settings page", href: "https://www.imghippo.com/settings" });
    ihList.createEl("li", { text: "Copy your API key and paste it below" });
    new import_obsidian3.Setting(containerEl).setName("API Key").setDesc("Your ImgHippo API key from the settings page").addText((text) => text.setPlaceholder("Your ImgHippo API key").setValue(this.plugin.settings.cloudProviders.imghippo.apiKey).onChange(async (value) => {
      this.plugin.settings.cloudProviders.imghippo.apiKey = value.trim();
      this.plugin.settings.cloudProviders.imghippo.enabled = !!value.trim();
      await this.plugin.saveSettings();
    }));
    new import_obsidian3.Setting(containerEl).setName("Test Connection").setDesc("Verify API key is valid").addButton((button) => button.setButtonText("Test").onClick(async () => {
      const config = this.plugin.settings.cloudProviders.imghippo;
      if (!config.apiKey) {
        new import_obsidian3.Notice("\u2717 Please enter an API key first");
        return;
      }
      new import_obsidian3.Notice("\u2713 ImgHippo API key configured");
    }));
  }
  renderS3Settings(containerEl) {
    new import_obsidian3.Setting(containerEl).setName("Amazon S3").setHeading();
    new import_obsidian3.Setting(containerEl).setName("Endpoint").setDesc("S3-compatible endpoint URL").addText((text) => text.setPlaceholder("https://s3.amazonaws.com").setValue(this.plugin.settings.cloudProviders.s3.endpoint).onChange(async (value) => {
      this.plugin.settings.cloudProviders.s3.endpoint = value.trim();
      await this.plugin.saveSettings();
    }));
    new import_obsidian3.Setting(containerEl).setName("Region").addText((text) => text.setPlaceholder("us-east-1").setValue(this.plugin.settings.cloudProviders.s3.region).onChange(async (value) => {
      this.plugin.settings.cloudProviders.s3.region = value.trim();
      await this.plugin.saveSettings();
    }));
    new import_obsidian3.Setting(containerEl).setName("Bucket").addText((text) => text.setPlaceholder("my-bucket").setValue(this.plugin.settings.cloudProviders.s3.bucket).onChange(async (value) => {
      this.plugin.settings.cloudProviders.s3.bucket = value.trim();
      await this.plugin.saveSettings();
    }));
    new import_obsidian3.Setting(containerEl).setName("Access Key ID").addText((text) => text.setValue(this.plugin.settings.cloudProviders.s3.accessKeyId).onChange(async (value) => {
      this.plugin.settings.cloudProviders.s3.accessKeyId = value.trim();
      await this.plugin.saveSettings();
    }));
    new import_obsidian3.Setting(containerEl).setName("Secret Access Key").addText((text) => text.setValue(this.plugin.settings.cloudProviders.s3.secretAccessKey).onChange(async (value) => {
      this.plugin.settings.cloudProviders.s3.secretAccessKey = value.trim();
      this.plugin.settings.cloudProviders.s3.enabled = !!(this.plugin.settings.cloudProviders.s3.endpoint && this.plugin.settings.cloudProviders.s3.accessKeyId && value.trim());
      await this.plugin.saveSettings();
    }));
    new import_obsidian3.Setting(containerEl).setName("Public URL (optional)").setDesc("Custom public URL for accessing uploaded files").addText((text) => text.setPlaceholder("https://cdn.example.com").setValue(this.plugin.settings.cloudProviders.s3.publicUrl).onChange(async (value) => {
      this.plugin.settings.cloudProviders.s3.publicUrl = value.trim();
      await this.plugin.saveSettings();
    }));
  }
  renderWebDAVSettings(containerEl) {
    new import_obsidian3.Setting(containerEl).setName("WebDAV").setHeading();
    containerEl.createEl("p", {
      text: "Works with Synology NAS, Nextcloud, ownCloud, or any WebDAV server.",
      cls: "setting-item-description"
    });
    new import_obsidian3.Setting(containerEl).setName("Server URL").addText((text) => text.setPlaceholder("https://nas.example.com/webdav").setValue(this.plugin.settings.cloudProviders.webdav.serverUrl).onChange(async (value) => {
      this.plugin.settings.cloudProviders.webdav.serverUrl = value.trim();
      await this.plugin.saveSettings();
    }));
    new import_obsidian3.Setting(containerEl).setName("Username").addText((text) => text.setValue(this.plugin.settings.cloudProviders.webdav.username).onChange(async (value) => {
      this.plugin.settings.cloudProviders.webdav.username = value.trim();
      await this.plugin.saveSettings();
    }));
    new import_obsidian3.Setting(containerEl).setName("Password").addText((text) => text.setValue(this.plugin.settings.cloudProviders.webdav.password).onChange(async (value) => {
      this.plugin.settings.cloudProviders.webdav.password = value;
      this.plugin.settings.cloudProviders.webdav.enabled = !!(this.plugin.settings.cloudProviders.webdav.serverUrl && this.plugin.settings.cloudProviders.webdav.username && value);
      await this.plugin.saveSettings();
    }));
    new import_obsidian3.Setting(containerEl).setName("Upload Path").setDesc("Directory path for uploads").addText((text) => text.setPlaceholder("/eagle-uploads").setValue(this.plugin.settings.cloudProviders.webdav.uploadPath).onChange(async (value) => {
      this.plugin.settings.cloudProviders.webdav.uploadPath = value.trim() || "/eagle-uploads";
      await this.plugin.saveSettings();
    }));
    new import_obsidian3.Setting(containerEl).setName("Public URL").setDesc("Public URL prefix for accessing uploaded files").addText((text) => text.setPlaceholder("https://public.example.com").setValue(this.plugin.settings.cloudProviders.webdav.publicUrl).onChange(async (value) => {
      this.plugin.settings.cloudProviders.webdav.publicUrl = value.trim();
      await this.plugin.saveSettings();
    }));
  }
  renderCustomSettings(containerEl) {
    new import_obsidian3.Setting(containerEl).setName("Custom server").setHeading();
    containerEl.createEl("p", {
      text: 'Configure a custom upload endpoint. Server should accept multipart/form-data with "file" field.',
      cls: "setting-item-description"
    });
    new import_obsidian3.Setting(containerEl).setName("Upload URL").addText((text) => text.setPlaceholder("https://your-server.com/upload").setValue(this.plugin.settings.cloudProviders.custom.uploadUrl).onChange(async (value) => {
      this.plugin.settings.cloudProviders.custom.uploadUrl = value.trim();
      this.plugin.settings.cloudProviders.custom.enabled = !!value.trim();
      await this.plugin.saveSettings();
    }));
    new import_obsidian3.Setting(containerEl).setName("Public URL").setDesc("Base URL for accessing uploaded files").addText((text) => text.setPlaceholder("https://cdn.your-server.com").setValue(this.plugin.settings.cloudProviders.custom.publicUrl).onChange(async (value) => {
      this.plugin.settings.cloudProviders.custom.publicUrl = value.trim();
      await this.plugin.saveSettings();
    }));
  }
  renderSearchFiltersSettings(containerEl) {
    const filterContainer = containerEl.createDiv({ cls: "cmdspace-eagle-settings-filters" });
    const scopeSection = filterContainer.createDiv({ cls: "cmdspace-eagle-settings-filter-section" });
    scopeSection.createEl("div", { text: "Default search scope", cls: "cmdspace-eagle-settings-filter-title" });
    const scopeButtons = scopeSection.createDiv({ cls: "cmdspace-eagle-settings-filter-buttons" });
    const scopes = [
      { key: "name", label: "Name" },
      { key: "tags", label: "Tags" },
      { key: "annotation", label: "Notes" },
      { key: "folders", label: "Folders" }
    ];
    scopes.forEach(({ key, label }) => {
      const btn = scopeButtons.createEl("button", {
        text: label,
        cls: `cmdspace-eagle-settings-filter-btn ${this.plugin.settings.searchScope.includes(key) ? "is-active" : ""}`
      });
      btn.addEventListener("click", () => {
        void (async () => {
          if (this.plugin.settings.searchScope.includes(key)) {
            if (this.plugin.settings.searchScope.length > 1) {
              this.plugin.settings.searchScope = this.plugin.settings.searchScope.filter((s) => s !== key);
              btn.removeClass("is-active");
            }
          } else {
            this.plugin.settings.searchScope.push(key);
            btn.addClass("is-active");
          }
          await this.plugin.saveSettings();
        })();
      });
    });
    const typeSection = filterContainer.createDiv({ cls: "cmdspace-eagle-settings-filter-section" });
    typeSection.createEl("div", { text: "Default file types", cls: "cmdspace-eagle-settings-filter-title" });
    const typeButtons = typeSection.createDiv({ cls: "cmdspace-eagle-settings-filter-buttons" });
    const hasAllImages = () => SUPPORTED_IMAGE_EXTENSIONS.every(
      (ext) => this.plugin.settings.searchFileTypes.includes(ext)
    );
    const hasAllVideos = () => SUPPORTED_VIDEO_EXTENSIONS.every(
      (ext) => this.plugin.settings.searchFileTypes.includes(ext)
    );
    const hasAllDocs = () => SUPPORTED_DOCUMENT_EXTENSIONS.every(
      (ext) => this.plugin.settings.searchFileTypes.includes(ext)
    );
    const imgBtn = typeButtons.createEl("button", {
      text: "Images",
      cls: `cmdspace-eagle-settings-filter-btn ${hasAllImages() ? "is-active" : ""}`
    });
    imgBtn.addEventListener("click", () => {
      void (async () => {
        if (hasAllImages()) {
          this.plugin.settings.searchFileTypes = this.plugin.settings.searchFileTypes.filter(
            (ext) => !SUPPORTED_IMAGE_EXTENSIONS.includes(ext)
          );
          imgBtn.removeClass("is-active");
        } else {
          SUPPORTED_IMAGE_EXTENSIONS.forEach((ext) => {
            if (!this.plugin.settings.searchFileTypes.includes(ext)) {
              this.plugin.settings.searchFileTypes.push(ext);
            }
          });
          imgBtn.addClass("is-active");
        }
        if (this.plugin.settings.searchFileTypes.length === 0) {
          this.plugin.settings.searchFileTypes = [...SUPPORTED_IMAGE_EXTENSIONS];
          imgBtn.addClass("is-active");
        }
        await this.plugin.saveSettings();
      })();
    });
    const vidBtn = typeButtons.createEl("button", {
      text: "Videos",
      cls: `cmdspace-eagle-settings-filter-btn ${hasAllVideos() ? "is-active" : ""}`
    });
    vidBtn.addEventListener("click", () => {
      void (async () => {
        if (hasAllVideos()) {
          this.plugin.settings.searchFileTypes = this.plugin.settings.searchFileTypes.filter(
            (ext) => !SUPPORTED_VIDEO_EXTENSIONS.includes(ext)
          );
          vidBtn.removeClass("is-active");
        } else {
          SUPPORTED_VIDEO_EXTENSIONS.forEach((ext) => {
            if (!this.plugin.settings.searchFileTypes.includes(ext)) {
              this.plugin.settings.searchFileTypes.push(ext);
            }
          });
          vidBtn.addClass("is-active");
        }
        if (this.plugin.settings.searchFileTypes.length === 0) {
          this.plugin.settings.searchFileTypes = [...SUPPORTED_IMAGE_EXTENSIONS];
          imgBtn.addClass("is-active");
        }
        await this.plugin.saveSettings();
      })();
    });
    const docBtn = typeButtons.createEl("button", {
      text: "Documents",
      cls: `cmdspace-eagle-settings-filter-btn ${hasAllDocs() ? "is-active" : ""}`
    });
    docBtn.addEventListener("click", () => {
      void (async () => {
        if (hasAllDocs()) {
          this.plugin.settings.searchFileTypes = this.plugin.settings.searchFileTypes.filter(
            (ext) => !SUPPORTED_DOCUMENT_EXTENSIONS.includes(ext)
          );
          docBtn.removeClass("is-active");
        } else {
          SUPPORTED_DOCUMENT_EXTENSIONS.forEach((ext) => {
            if (!this.plugin.settings.searchFileTypes.includes(ext)) {
              this.plugin.settings.searchFileTypes.push(ext);
            }
          });
          docBtn.addClass("is-active");
        }
        if (this.plugin.settings.searchFileTypes.length === 0) {
          this.plugin.settings.searchFileTypes = [...SUPPORTED_IMAGE_EXTENSIONS];
          imgBtn.addClass("is-active");
        }
        await this.plugin.saveSettings();
      })();
    });
  }
  renderCrossPlatformSettings(containerEl) {
    const infoEl = containerEl.createEl("div", { cls: "setting-item-description cmds-eagle-info-block" });
    infoEl.createEl("p", { text: "Enable this to use the same vault on multiple computers (macOS/Windows)." });
    infoEl.createEl("p", { text: "File paths will be automatically converted based on the current computer.", cls: "cmds-eagle-muted" });
    new import_obsidian3.Setting(containerEl).setName("Enable cross-platform path conversion").setDesc("Convert file:// paths between registered computers").addToggle((toggle) => toggle.setValue(this.plugin.settings.enableCrossPlatform).onChange(async (value) => {
      this.plugin.settings.enableCrossPlatform = value;
      await this.plugin.saveSettings();
      this.display();
    }));
    if (!this.plugin.settings.enableCrossPlatform) {
      return;
    }
    new import_obsidian3.Setting(containerEl).setName("Auto-convert paths on file open").setDesc("Automatically convert cross-platform paths when opening a note").addToggle((toggle) => toggle.setValue(this.plugin.settings.autoConvertCrossPlatformPaths).onChange(async (value) => {
      this.plugin.settings.autoConvertCrossPlatformPaths = value;
      await this.plugin.saveSettings();
    }));
    const currentPlatform = process.platform;
    const currentUsername = this.detectCurrentUsername();
    new import_obsidian3.Setting(containerEl).setName("Add current computer").setDesc(`Detected: ${currentPlatform === "darwin" ? "macOS" : "Windows"} / ${currentUsername}`).addButton((button) => button.setButtonText("Add").onClick(async () => {
      const existingIndex = this.plugin.settings.computers.findIndex(
        (c) => c.platform === currentPlatform && c.username === currentUsername
      );
      if (existingIndex >= 0) {
        new import_obsidian3.Notice("This computer is already registered");
        return;
      }
      const newProfile = {
        id: `${currentPlatform}-${currentUsername}-${Date.now()}`,
        name: currentPlatform === "darwin" ? `Mac (${currentUsername})` : `Windows (${currentUsername})`,
        platform: currentPlatform,
        username: currentUsername,
        subPath: "",
        eagleLibraryPath: "",
        isCurrentComputer: true
      };
      this.plugin.settings.computers.push(newProfile);
      await this.plugin.saveSettings();
      this.display();
      new import_obsidian3.Notice("Current computer added");
    }));
    if (this.plugin.settings.computers.length > 0) {
      const listContainer = containerEl.createDiv({ cls: "cmdspace-eagle-computer-list" });
      listContainer.createEl("div", {
        text: "Registered Computers",
        cls: "cmdspace-eagle-computer-list-title"
      });
      for (const computer of this.plugin.settings.computers) {
        const isCurrentComputer = computer.platform === currentPlatform && computer.username === currentUsername;
        const computerEl = listContainer.createDiv({ cls: "cmdspace-eagle-computer-item" });
        if (isCurrentComputer) {
          computerEl.addClass("is-current");
        }
        const headerRow = computerEl.createDiv({ attr: { style: "display: flex; justify-content: space-between; align-items: center; width: 100%;" } });
        const infoDiv = headerRow.createDiv({ attr: { style: "flex: 1;" } });
        const platformIcon = computer.platform === "darwin" ? "\u{1F34E}" : "\u{1FA9F}";
        infoDiv.createEl("div", {
          text: `${platformIcon} ${computer.name}`,
          attr: { style: "font-weight: 500;" }
        });
        infoDiv.createEl("div", {
          text: `${computer.platform === "darwin" ? "macOS" : "Windows"} \u2022 ${computer.username}${isCurrentComputer ? " (current)" : ""}`,
          attr: { style: "font-size: 12px; color: var(--text-muted);" }
        });
        const deleteBtn = headerRow.createEl("button", { text: "\xD7", cls: "cmdspace-eagle-computer-delete" });
        const subPathContainer = computerEl.createDiv({ attr: { style: "margin-top: 8px; width: 100%;" } });
        subPathContainer.createEl("label", {
          text: "Sub-path (folders between /Users/name/ and sync folder)",
          attr: { style: "font-size: 11px; color: var(--text-muted); display: block; margin-bottom: 4px;" }
        });
        const subPathInput = subPathContainer.createEl("input", {
          type: "text",
          value: computer.subPath || "",
          placeholder: "e.g., OneDrive or Dropbox/Work",
          attr: { style: "width: 100%; padding: 4px 8px; border-radius: 4px; border: 1px solid var(--background-modifier-border);" }
        });
        subPathInput.addEventListener("change", () => {
          void (async () => {
            const idx = this.plugin.settings.computers.findIndex((c) => c.id === computer.id);
            if (idx >= 0) {
              this.plugin.settings.computers[idx].subPath = subPathInput.value.trim();
              await this.plugin.saveSettings();
            }
          })();
        });
        deleteBtn.addEventListener("click", () => {
          void (async () => {
            this.plugin.settings.computers = this.plugin.settings.computers.filter((c) => c.id !== computer.id);
            await this.plugin.saveSettings();
            this.display();
            new import_obsidian3.Notice("Computer removed");
          })();
        });
      }
    }
  }
  detectCurrentUsername() {
    const adapter = this.app.vault.adapter;
    const vaultPath = adapter.basePath || "";
    const platform = process.platform;
    if (platform === "darwin") {
      const match = vaultPath.match(/^\/Users\/([^/]+)/);
      if (match)
        return match[1];
    } else if (platform === "win32") {
      const match = vaultPath.match(/^[A-Za-z]:[/\\]Users[/\\]([^/\\]+)/i);
      if (match)
        return match[1];
    }
    return "unknown";
  }
};

// src/cloud-providers.ts
var import_obsidian4 = require("obsidian");
var import_fs2 = require("fs");
function getMimeType2(ext) {
  const MIME_TYPES2 = {
    "jpg": "image/jpeg",
    "jpeg": "image/jpeg",
    "png": "image/png",
    "gif": "image/gif",
    "webp": "image/webp",
    "svg": "image/svg+xml",
    "bmp": "image/bmp",
    "ico": "image/x-icon",
    "tiff": "image/tiff",
    "tif": "image/tiff",
    "heic": "image/heic",
    "heif": "image/heif",
    "avif": "image/avif",
    "pdf": "application/pdf"
  };
  return MIME_TYPES2[ext.toLowerCase()] || "application/octet-stream";
}
var R2Provider = class {
  constructor(config) {
    this.config = config;
  }
  async upload(filePath, filename, mimeType) {
    if (!this.config.workerUrl || !this.config.apiKey) {
      return { success: false, error: "R2 not configured" };
    }
    try {
      const fileBuffer = await import_fs2.promises.readFile(filePath);
      const blob = new Blob([fileBuffer], { type: mimeType });
      const formData = new FormData();
      formData.append("file", blob, filename);
      formData.append("filename", filename);
      formData.append("content_type", mimeType);
      const response = await window.fetch(`${this.config.workerUrl}/upload`, {
        method: "POST",
        headers: {
          "Authorization": `Bearer ${this.config.apiKey}`
        },
        body: formData
      });
      if (!response.ok) {
        const errorText = await response.text();
        return { success: false, error: `Upload failed (${response.status}): ${errorText}` };
      }
      const result = await response.json();
      return {
        success: true,
        key: result.key,
        filename: result.filename,
        publicUrl: this.getPublicUrl(result.key)
      };
    } catch (error) {
      return {
        success: false,
        error: error instanceof Error ? error.message : "Unknown error"
      };
    }
  }
  async testConnection() {
    if (!this.config.workerUrl || !this.config.apiKey) {
      return false;
    }
    try {
      const response = await window.fetch(`${this.config.workerUrl}/health`, {
        method: "GET",
        headers: {
          "Authorization": `Bearer ${this.config.apiKey}`
        }
      });
      return response.status === 200;
    } catch (e) {
      return false;
    }
  }
  getPublicUrl(key) {
    return `${this.config.publicUrl}/${key}`;
  }
};
var S3Provider = class {
  constructor(config) {
    this.config = config;
  }
  async upload(filePath, filename, mimeType) {
    if (!this.config.endpoint || !this.config.accessKeyId || !this.config.secretAccessKey) {
      return { success: false, error: "S3 not configured" };
    }
    try {
      const fileBuffer = await import_fs2.promises.readFile(filePath);
      const key = `eagle/${Date.now()}-${filename}`;
      const date = new Date().toISOString().replace(/[:-]|\.\d{3}/g, "");
      const dateStamp = date.slice(0, 8);
      const host = new URL(this.config.endpoint).host;
      const canonicalUri = `/${this.config.bucket}/${key}`;
      const canonicalQueryString = "";
      const payloadHash = await this.sha256(fileBuffer);
      const canonicalHeaders = [
        `content-type:${mimeType}`,
        `host:${host}`,
        `x-amz-content-sha256:${payloadHash}`,
        `x-amz-date:${date}`
      ].join("\n") + "\n";
      const signedHeaders = "content-type;host;x-amz-content-sha256;x-amz-date";
      const canonicalRequest = [
        "PUT",
        canonicalUri,
        canonicalQueryString,
        canonicalHeaders,
        signedHeaders,
        payloadHash
      ].join("\n");
      const algorithm = "AWS4-HMAC-SHA256";
      const credentialScope = `${dateStamp}/${this.config.region}/s3/aws4_request`;
      const stringToSign = [
        algorithm,
        date,
        credentialScope,
        await this.sha256(new TextEncoder().encode(canonicalRequest))
      ].join("\n");
      const signingKey = await this.getSignatureKey(
        this.config.secretAccessKey,
        dateStamp,
        this.config.region,
        "s3"
      );
      const signature = await this.hmacHex(signingKey, stringToSign);
      const authorizationHeader = `${algorithm} Credential=${this.config.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
      const response = await window.fetch(`${this.config.endpoint}/${this.config.bucket}/${key}`, {
        method: "PUT",
        headers: {
          "Content-Type": mimeType,
          "x-amz-content-sha256": payloadHash,
          "x-amz-date": date,
          "Authorization": authorizationHeader
        },
        body: fileBuffer
      });
      if (!response.ok) {
        const errorText = await response.text();
        return { success: false, error: `S3 upload failed (${response.status}): ${errorText}` };
      }
      return {
        success: true,
        key,
        filename,
        publicUrl: this.getPublicUrl(key)
      };
    } catch (error) {
      return {
        success: false,
        error: error instanceof Error ? error.message : "Unknown error"
      };
    }
  }
  async testConnection() {
    if (!this.config.endpoint || !this.config.accessKeyId) {
      return false;
    }
    try {
      const response = await window.fetch(`${this.config.endpoint}/${this.config.bucket}`, {
        method: "HEAD"
      });
      return response.status < 500;
    } catch (e) {
      return false;
    }
  }
  getPublicUrl(key) {
    if (this.config.publicUrl) {
      return `${this.config.publicUrl}/${key}`;
    }
    return `${this.config.endpoint}/${this.config.bucket}/${key}`;
  }
  async sha256(data) {
    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
    return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
  }
  async hmac(key, data) {
    const cryptoKey = await crypto.subtle.importKey(
      "raw",
      key,
      { name: "HMAC", hash: "SHA-256" },
      false,
      ["sign"]
    );
    return await crypto.subtle.sign("HMAC", cryptoKey, new TextEncoder().encode(data));
  }
  async hmacHex(key, data) {
    const sig = await this.hmac(key, data);
    return Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
  }
  async getSignatureKey(key, dateStamp, region, service) {
    const kDate = await this.hmac(new TextEncoder().encode("AWS4" + key), dateStamp);
    const kRegion = await this.hmac(kDate, region);
    const kService = await this.hmac(kRegion, service);
    return await this.hmac(kService, "aws4_request");
  }
};
var WebDAVProvider = class {
  constructor(config) {
    this.config = config;
  }
  async upload(filePath, filename, mimeType) {
    if (!this.config.serverUrl || !this.config.username) {
      return { success: false, error: "WebDAV not configured" };
    }
    try {
      const fileBuffer = await import_fs2.promises.readFile(filePath);
      const key = `${this.config.uploadPath}/${Date.now()}-${filename}`;
      const uploadUrl = `${this.config.serverUrl}${key}`;
      const auth = btoa(`${this.config.username}:${this.config.password}`);
      const response = await window.fetch(uploadUrl, {
        method: "PUT",
        headers: {
          "Authorization": `Basic ${auth}`,
          "Content-Type": mimeType
        },
        body: fileBuffer
      });
      if (!response.ok && response.status !== 201 && response.status !== 204) {
        return { success: false, error: `WebDAV upload failed (${response.status})` };
      }
      return {
        success: true,
        key,
        filename,
        publicUrl: this.getPublicUrl(key)
      };
    } catch (error) {
      return {
        success: false,
        error: error instanceof Error ? error.message : "Unknown error"
      };
    }
  }
  async testConnection() {
    if (!this.config.serverUrl || !this.config.username) {
      return false;
    }
    try {
      const auth = btoa(`${this.config.username}:${this.config.password}`);
      const response = await window.fetch(this.config.serverUrl, {
        method: "PROPFIND",
        headers: {
          "Authorization": `Basic ${auth}`,
          "Depth": "0"
        }
      });
      return response.status === 207 || response.status === 200;
    } catch (e) {
      return false;
    }
  }
  getPublicUrl(key) {
    if (this.config.publicUrl) {
      return `${this.config.publicUrl}${key}`;
    }
    return `${this.config.serverUrl}${key}`;
  }
};
var ImgHippoProvider = class {
  constructor(config) {
    this.config = config;
    this.API_URL = "https://api.imghippo.com/v1/upload";
  }
  async upload(filePath, filename, mimeType) {
    var _a, _b;
    if (!this.config.apiKey) {
      return { success: false, error: "ImgHippo API key not configured" };
    }
    try {
      const fileBuffer = await import_fs2.promises.readFile(filePath);
      const boundary = `----CmdsEagleBoundary${Date.now().toString(16)}`;
      const encoder = new TextEncoder();
      const head = encoder.encode(
        `--${boundary}\r
Content-Disposition: form-data; name="api_key"\r
\r
${this.config.apiKey}\r
--${boundary}\r
Content-Disposition: form-data; name="title"\r
\r
${filename}\r
--${boundary}\r
Content-Disposition: form-data; name="file"; filename="${filename}"\r
Content-Type: ${mimeType}\r
\r
`
      );
      const tail = encoder.encode(`\r
--${boundary}--\r
`);
      const body = new Uint8Array(head.length + fileBuffer.length + tail.length);
      body.set(head, 0);
      body.set(fileBuffer, head.length);
      body.set(tail, head.length + fileBuffer.length);
      const response = await (0, import_obsidian4.requestUrl)({
        url: this.API_URL,
        method: "POST",
        contentType: `multipart/form-data; boundary=${boundary}`,
        body: body.buffer,
        throw: false
      });
      if (response.status < 200 || response.status >= 300) {
        return { success: false, error: `ImgHippo upload failed (${response.status}): ${(response.text || "").slice(0, 200)}` };
      }
      const result = response.json;
      if (!result.success || !result.data) {
        return { success: false, error: result.message || "Upload failed" };
      }
      const publicUrl = result.data.url || result.data.display_url || ((_a = result.data.image) == null ? void 0 : _a.url);
      const resultFilename = ((_b = result.data.image) == null ? void 0 : _b.filename) || result.data.title || filename;
      if (!publicUrl) {
        return { success: false, error: "No URL returned from ImgHippo" };
      }
      return {
        success: true,
        key: result.data.id,
        filename: resultFilename,
        publicUrl
      };
    } catch (error) {
      return {
        success: false,
        error: error instanceof Error ? error.message : "Unknown error"
      };
    }
  }
  async testConnection() {
    return !!this.config.apiKey;
  }
  getPublicUrl(key) {
    return key;
  }
};
var CustomProvider = class {
  constructor(config) {
    this.config = config;
  }
  async upload(filePath, filename, mimeType) {
    if (!this.config.uploadUrl) {
      return { success: false, error: "Custom provider not configured" };
    }
    try {
      const fileBuffer = await import_fs2.promises.readFile(filePath);
      const blob = new Blob([fileBuffer], { type: mimeType });
      const formData = new FormData();
      formData.append("file", blob, filename);
      formData.append("filename", filename);
      const response = await window.fetch(this.config.uploadUrl, {
        method: "POST",
        headers: this.config.headers,
        body: formData
      });
      if (!response.ok) {
        const errorText = await response.text();
        return { success: false, error: `Upload failed (${response.status}): ${errorText}` };
      }
      const result = await response.json();
      const key = result.key || result.url || filename;
      return {
        success: true,
        key,
        filename: result.filename || filename,
        publicUrl: this.getPublicUrl(key)
      };
    } catch (error) {
      return {
        success: false,
        error: error instanceof Error ? error.message : "Unknown error"
      };
    }
  }
  async testConnection() {
    if (!this.config.uploadUrl) {
      return false;
    }
    try {
      const response = await window.fetch(this.config.uploadUrl, {
        method: "HEAD",
        headers: this.config.headers
      });
      return response.status < 500;
    } catch (e) {
      return false;
    }
  }
  getPublicUrl(key) {
    if (this.config.publicUrl) {
      return key.startsWith("http") ? key : `${this.config.publicUrl}/${key}`;
    }
    return key;
  }
};
function createCloudProvider(config) {
  switch (config.type) {
    case "r2":
      return new R2Provider(config);
    case "s3":
      return new S3Provider(config);
    case "webdav":
      return new WebDAVProvider(config);
    case "imghippo":
      return new ImgHippoProvider(config);
    case "custom":
      return new CustomProvider(config);
    default:
      return null;
  }
}
function getExtFromFilename(filename) {
  const parts = filename.split(".");
  return parts.length > 1 ? parts[parts.length - 1].toLowerCase() : "";
}

// src/main.ts
var CMDSPACELinkEagle = class extends import_obsidian5.Plugin {
  constructor() {
    super(...arguments);
    this.lastModifiedFile = null;
    this.attachedExcalidrawContainers = /* @__PURE__ */ new WeakSet();
  }
  async onload() {
    console.log("[CMDS Eagle] Loading plugin v1.6.0");
    await this.loadSettings();
    this.api = new EagleApiService(this.settings);
    this.addCommand({
      id: "search-eagle",
      name: "Search Eagle library and embed",
      editorCallback: (editor, view) => {
        new EagleSearchModal(this.app, this.api, this.settings).open();
      }
    });
    this.addCommand({
      id: "upload-clipboard-to-cloud",
      name: "Upload clipboard Eagle image to cloud",
      editorCallback: async (editor, view) => {
        await this.uploadClipboardToCloud(editor);
      }
    });
    this.addCommand({
      id: "embed-and-upload",
      name: "Embed Eagle image and upload to cloud",
      editorCallback: async (editor, view) => {
        await this.embedAndUploadToCloud(editor);
      }
    });
    this.addCommand({
      id: "convert-all-to-cloud",
      name: "Convert all images in note to cloud URLs",
      callback: async () => {
        await this.uploadAllImagesToCloud();
      }
    });
    this.addCommand({
      id: "convert-cross-platform-paths",
      name: "Convert cross-platform image paths in current note",
      callback: async () => {
        await this.convertCrossPlatformPaths();
      }
    });
    this.registerEvent(
      this.app.workspace.on("editor-paste", (evt, editor) => {
        if (evt.defaultPrevented)
          return;
        if (!this.willHandlePaste(evt))
          return;
        evt.preventDefault();
        void this.handlePaste(evt, editor);
      })
    );
    this.registerEvent(
      this.app.workspace.on("editor-drop", (evt, editor) => {
        if (evt.defaultPrevented)
          return;
        if (!this.willHandleDrop(evt))
          return;
        evt.preventDefault();
        void this.handleDrop(evt, editor);
      })
    );
    this.registerEvent(
      this.app.workspace.on("editor-menu", (menu, editor) => {
        const localImage = this.getLocalImageUnderCursor(editor);
        if (localImage) {
          menu.addItem((item) => {
            item.setTitle("Upload to Eagle").setIcon("upload").onClick(() => this.uploadLocalImageToEagle(editor, localImage));
          });
        }
      })
    );
    this.addSettingTab(new CMDSPACEEagleSettingTab(this.app, this));
    this.registerMarkdownPostProcessor((el, ctx) => {
      this.processEagleLinks(el);
    });
    this.registerEvent(
      this.app.workspace.on("active-leaf-change", () => {
        window.setTimeout(() => this.processActiveView(), 100);
      })
    );
    this.registerEvent(
      this.app.workspace.on("layout-change", () => {
        window.setTimeout(() => this.processActiveView(), 100);
      })
    );
    this.registerEvent(
      this.app.vault.on("modify", (file) => {
        this.lastModifiedFile = file.path;
      })
    );
    this.registerEvent(
      this.app.workspace.on("file-open", (file) => {
        console.log(`[CMDS Eagle] file-open event: ${file == null ? void 0 : file.path}`);
        console.log(`[CMDS Eagle] enableCrossPlatform: ${this.settings.enableCrossPlatform}`);
        console.log(`[CMDS Eagle] autoConvertCrossPlatformPaths: ${this.settings.autoConvertCrossPlatformPaths}`);
        console.log(`[CMDS Eagle] conversionMode: ${this.settings.crossPlatformConversionMode}`);
        console.log(`[CMDS Eagle] lastModifiedFile: ${this.lastModifiedFile}`);
        if (file && this.settings.enableCrossPlatform && this.settings.autoConvertCrossPlatformPaths) {
          if (this.lastModifiedFile !== file.path) {
            console.log(`[CMDS Eagle] Triggering auto-conversion for: ${file.path}`);
            window.setTimeout(() => {
              void this.autoConvertOnFileOpen(file);
            }, 300);
          } else {
            console.log(`[CMDS Eagle] Skipping - file was just modified by us`);
          }
        }
        this.lastModifiedFile = null;
      })
    );
    this.addRibbonIcon("image", "CMDSPACE: Eagle", () => {
      new EagleSearchModal(this.app, this.api, this.settings).open();
    });
    this.registerExcalidrawIntegration();
  }
  onunload() {
    console.log("[CMDS Eagle] Unloading plugin");
  }
  async loadSettings() {
    const saved = await this.loadData();
    this.settings = Object.assign({}, DEFAULT_SETTINGS, saved);
  }
  async saveSettings() {
    await this.saveData(this.settings);
    if (this.api) {
      this.api.updateSettings(this.settings);
    }
  }
  async insertFromClipboard(editor) {
    const clipboardText = await navigator.clipboard.readText();
    const parsed = parseEagleUrl(clipboardText.trim());
    if (!parsed || parsed.type !== "item") {
      new import_obsidian5.Notice("Clipboard does not contain a valid Eagle item URL");
      return;
    }
    const item = await this.api.getItemInfo(parsed.id);
    if (!item) {
      new import_obsidian5.Notice("Could not fetch item info from Eagle");
      return;
    }
    void this.insertItemLink(editor, item);
    new import_obsidian5.Notice(`Inserted link to: ${item.name}`);
  }
  async insertItemLink(editor, item) {
    if (this.settings.insertAsEmbed) {
      const filePath = await this.api.getOriginalFilePath(item);
      if (filePath) {
        const fileUrl = this.pathToFileUrl(filePath);
        const filename = `${item.name}.${item.ext}`;
        let output = `![${filename}](${fileUrl})`;
        if (this.settings.insertThumbnail) {
          output += "\n\n" + this.buildMetadataCard(item);
        }
        editor.replaceSelection(output);
        return;
      }
    }
    const linkUrl = buildEagleItemUrl(item.id);
    if (this.settings.insertThumbnail) {
      const card = this.buildLinkCard(item);
      editor.replaceSelection(card);
    } else {
      const link = this.settings.linkFormat === "wikilink" ? `[[${linkUrl}|${item.name}]]` : `[${item.name}](${linkUrl})`;
      editor.replaceSelection(link);
    }
  }
  buildMetadataCard(item) {
    const linkUrl = buildEagleItemUrl(item.id);
    const tags = item.tags.filter((t) => !t.startsWith("r2:") && t !== "r2-cloud" && t !== "cloud-upload").map((t) => `#${this.normalizeTag(t)}`).join(" ");
    const dimensions = item.width && item.height ? `${item.width}\xD7${item.height}` : "N/A";
    const isUploaded = hasR2Upload(item);
    const cloudUrl = this.api.getCloudUrl(item);
    let linkSection = `[Open in Eagle](${linkUrl})`;
    if (cloudUrl) {
      linkSection += ` | [Cloud](${cloudUrl})`;
    }
    return `> **${item.ext.toUpperCase()}** | ${this.formatFileSize(item.size)} | ${dimensions} | ${isUploaded ? "\u2601\uFE0F" : "\u{1F4C1}"} | ${tags || "No tags"}
> ${linkSection}`;
  }
  buildLinkCard(item) {
    const linkUrl = buildEagleItemUrl(item.id);
    const tags = item.tags.filter((t) => !t.startsWith("r2:") && t !== "r2-cloud").map((t) => `#${this.normalizeTag(t)}`).join(" ");
    const dimensions = item.width && item.height ? `${item.width}\xD7${item.height}` : "N/A";
    const imageUrl = this.getImageUrl(item);
    const cloudUrl = this.api.getCloudUrl(item);
    const isUploaded = hasR2Upload(item);
    let imageSection = "";
    if (this.settings.embedImageInCard && imageUrl) {
      imageSection = `> ![${item.name}](${imageUrl})
>
`;
    }
    let linkSection = `> [Open in Eagle](${linkUrl})`;
    if (cloudUrl) {
      linkSection += ` | [Cloud URL](${cloudUrl})`;
    }
    return `> [!cmdspace-eagle] ${item.name}
> 
${imageSection}> | Property | Value |
> |----------|-------|
> | **Type** | ${item.ext.toUpperCase()} |
> | **Size** | ${this.formatFileSize(item.size)} |
> | **Dimensions** | ${dimensions} |
> | **R2 Status** | ${isUploaded ? "\u2601\uFE0F Uploaded" : "\u{1F4C1} Local only"} |
> | **Tags** | ${tags || "None"} |
${item.annotation ? `> | **Annotation** | ${item.annotation} |
` : ""}${linkSection}

`;
  }
  getImageUrl(item) {
    const cloudUrl = this.api.getCloudUrl(item);
    const localUrl = this.api.getLocalThumbnailUrl(item.id);
    switch (this.settings.imageDisplayMode) {
      case "cloud":
        return cloudUrl || localUrl;
      case "local":
        return localUrl;
      case "both":
        return cloudUrl || localUrl;
      default:
        return cloudUrl || localUrl;
    }
  }
  async refreshCurrentNoteMetadata() {
    const activeFile = this.app.workspace.getActiveFile();
    if (!activeFile) {
      new import_obsidian5.Notice("No active file");
      return;
    }
    const content = await this.app.vault.read(activeFile);
    const eagleLinks = this.extractEagleLinks(content);
    if (eagleLinks.length === 0) {
      new import_obsidian5.Notice("No Eagle links found in current note");
      return;
    }
    new import_obsidian5.Notice(`Found ${eagleLinks.length} Eagle links. Refreshing...`);
    for (const id of eagleLinks) {
      const item = await this.api.getItemInfo(id);
      if (item) {
        console.log(`Refreshed: ${item.name}`);
      }
    }
    new import_obsidian5.Notice("Eagle metadata refreshed");
  }
  extractEagleLinks(content) {
    const regex = /eagle:\/\/item\/([A-Z0-9]+)/gi;
    const matches = [];
    let match;
    while ((match = regex.exec(content)) !== null) {
      matches.push(match[1]);
    }
    return [...new Set(matches)];
  }
  async syncTagsToEagle() {
    var _a;
    const activeFile = this.app.workspace.getActiveFile();
    if (!activeFile) {
      new import_obsidian5.Notice("No active file");
      return;
    }
    const metadata = this.app.metadataCache.getFileCache(activeFile);
    const tags = ((_a = metadata == null ? void 0 : metadata.tags) == null ? void 0 : _a.map((t) => t.tag.replace("#", ""))) || [];
    const content = await this.app.vault.read(activeFile);
    const eagleLinks = this.extractEagleLinks(content);
    if (eagleLinks.length === 0) {
      new import_obsidian5.Notice("No Eagle links found in current note");
      return;
    }
    let updated = 0;
    for (const id of eagleLinks) {
      const success = await this.api.updateItem(id, { tags });
      if (success)
        updated++;
    }
    new import_obsidian5.Notice(`Synced tags to ${updated}/${eagleLinks.length} Eagle items`);
  }
  async syncTagsFromEagle() {
    const activeFile = this.app.workspace.getActiveFile();
    if (!activeFile) {
      new import_obsidian5.Notice("No active file");
      return;
    }
    const content = await this.app.vault.read(activeFile);
    const eagleLinks = this.extractEagleLinks(content);
    if (eagleLinks.length === 0) {
      new import_obsidian5.Notice("No Eagle links found in current note");
      return;
    }
    const allTags = /* @__PURE__ */ new Set();
    for (const id of eagleLinks) {
      const item = await this.api.getItemInfo(id);
      if (item) {
        item.tags.forEach((t) => allTags.add(this.normalizeTag(t)));
      }
    }
    if (allTags.size === 0) {
      new import_obsidian5.Notice("No tags found in linked Eagle items");
      return;
    }
    await this.app.fileManager.processFrontMatter(activeFile, (frontmatter) => {
      const existingTags = frontmatter.tags || [];
      frontmatter.tags = [.../* @__PURE__ */ new Set([...existingTags, ...allTags])];
    });
    new import_obsidian5.Notice(`Added ${allTags.size} tags from Eagle items`);
  }
  async captureUrlToEagle(editor) {
    const clipboardText = await navigator.clipboard.readText();
    if (!clipboardText.startsWith("http://") && !clipboardText.startsWith("https://")) {
      new import_obsidian5.Notice("Clipboard does not contain a valid URL");
      return;
    }
    const connected = await this.api.isConnected();
    if (!connected) {
      new import_obsidian5.Notice("Eagle is not running");
      return;
    }
    const name = `Captured from Obsidian - ${new Date().toISOString()}`;
    const success = await this.api.addFromUrl({
      url: clipboardText,
      name,
      folderId: this.settings.defaultFolder || void 0
    });
    if (success) {
      new import_obsidian5.Notice("URL captured to Eagle");
      editor.replaceSelection(`[Captured: ${clipboardText}]`);
    } else {
      new import_obsidian5.Notice("Failed to capture URL to Eagle");
    }
  }
  async openEagleItemUnderCursor(editor) {
    const cursor = editor.getCursor();
    const line = editor.getLine(cursor.line);
    const match = line.match(/eagle:\/\/item\/([A-Z0-9]+)/i);
    if (!match) {
      new import_obsidian5.Notice("No Eagle link found on current line");
      return;
    }
    const url = `eagle://item/${match[1]}`;
    window.open(url);
  }
  async uploadClipboardToCloud(editor) {
    const clipboardText = (await navigator.clipboard.readText()).trim();
    let itemId = null;
    let directFilePath = null;
    const eagleParsed = parseEagleUrl(clipboardText);
    if (eagleParsed && eagleParsed.type === "item") {
      itemId = eagleParsed.id;
    }
    if (!itemId) {
      const localhostId = parseEagleLocalhostUrl(clipboardText);
      if (localhostId) {
        itemId = localhostId;
      }
    }
    if (!itemId && this.isEagleLibraryPath(clipboardText)) {
      directFilePath = clipboardText;
      const idMatch = clipboardText.match(/images\/([A-Z0-9]+)\.info/i);
      if (idMatch) {
        itemId = idMatch[1];
      }
    }
    if (!itemId && !directFilePath) {
      new import_obsidian5.Notice("Clipboard does not contain a valid Eagle URL or file path.\nSupported: eagle://item/ID, localhost URL, or Eagle library path");
      return;
    }
    const provider = this.getActiveCloudProvider();
    if (!provider) {
      new import_obsidian5.Notice("No cloud provider configured. Check settings.");
      return;
    }
    if (itemId) {
      const item = await this.api.getItemInfo(itemId);
      if (!item) {
        new import_obsidian5.Notice("Could not fetch item info from Eagle");
        return;
      }
      if (hasR2Upload(item)) {
        const cloudUrl = this.api.getCloudUrl(item);
        new import_obsidian5.Notice(`Already uploaded: ${cloudUrl}`);
        if (cloudUrl) {
          await navigator.clipboard.writeText(cloudUrl);
        }
        return;
      }
      new import_obsidian5.Notice(`Uploading ${item.name} to cloud...`);
      const filePath = await this.api.getOriginalFilePath(item);
      if (!filePath) {
        new import_obsidian5.Notice("Could not get file path from Eagle");
        return;
      }
      const filename = `${item.name}.${item.ext}`;
      const mimeType = getMimeType2(item.ext);
      const result = await provider.upload(filePath, filename, mimeType);
      if (result.success && result.publicUrl) {
        new import_obsidian5.Notice(`Uploaded! Cloud URL copied to clipboard`);
        await navigator.clipboard.writeText(result.publicUrl);
        const markdown = `![${filename}](${result.publicUrl})`;
        editor.replaceSelection(markdown);
        const r2Tag = `r2:${result.key}`;
        const newTags = [...item.tags];
        if (!newTags.includes(r2Tag) && result.key) {
          newTags.push(r2Tag);
        }
        if (!newTags.includes("cloud-upload")) {
          newTags.push("cloud-upload");
        }
        await this.api.updateItem(item.id, { tags: newTags });
      } else {
        new import_obsidian5.Notice(`Upload failed: ${result.error}`);
      }
    } else if (directFilePath) {
      const filename = directFilePath.split("/").pop() || "image";
      const ext = getExtFromFilename(filename);
      const mimeType = getMimeType2(ext);
      new import_obsidian5.Notice(`Uploading ${filename} to cloud...`);
      const result = await provider.upload(directFilePath, filename, mimeType);
      if (result.success && result.publicUrl) {
        new import_obsidian5.Notice(`Uploaded! Cloud URL copied to clipboard`);
        await navigator.clipboard.writeText(result.publicUrl);
        const markdown = `![${filename}](${result.publicUrl})`;
        editor.replaceSelection(markdown);
      } else {
        new import_obsidian5.Notice(`Upload failed: ${result.error}`);
      }
    }
  }
  async embedAndUploadToCloud(editor) {
    const clipboardText = (await navigator.clipboard.readText()).trim();
    let itemId = null;
    let directFilePath = null;
    const eagleParsed = parseEagleUrl(clipboardText);
    if (eagleParsed && eagleParsed.type === "item") {
      itemId = eagleParsed.id;
    }
    if (!itemId) {
      const localhostId = parseEagleLocalhostUrl(clipboardText);
      if (localhostId) {
        itemId = localhostId;
      }
    }
    if (!itemId && this.isEagleLibraryPath(clipboardText)) {
      directFilePath = clipboardText;
      const idMatch = clipboardText.match(/images\/([A-Z0-9]+)\.info/i);
      if (idMatch) {
        itemId = idMatch[1];
      }
    }
    if (!itemId && !directFilePath) {
      new import_obsidian5.Notice("Clipboard does not contain a valid Eagle URL or file path");
      return;
    }
    const provider = this.getActiveCloudProvider();
    if (!provider) {
      new import_obsidian5.Notice("No cloud provider configured. Check settings.");
      return;
    }
    const providerName = this.getActiveCloudProviderName();
    if (itemId) {
      const item = await this.api.getItemInfo(itemId);
      if (!item) {
        new import_obsidian5.Notice("Could not fetch item info from Eagle");
        return;
      }
      const filePath = await this.api.getOriginalFilePath(item);
      if (!filePath) {
        new import_obsidian5.Notice("Could not get file path from Eagle");
        return;
      }
      new import_obsidian5.Notice(`Uploading ${item.name} to ${providerName}...`);
      const filename = `${item.name}.${item.ext}`;
      const mimeType = getMimeType2(item.ext);
      const result = await provider.upload(filePath, filename, mimeType);
      if (result.success && result.publicUrl) {
        const markdown = `![${filename}](${result.publicUrl})`;
        editor.replaceSelection(markdown);
        new import_obsidian5.Notice(`Embedded and uploaded to ${providerName}!`);
        if (result.key) {
          const cloudTag = `cloud:${result.key}`;
          const newTags = [...item.tags];
          if (!newTags.includes(cloudTag)) {
            newTags.push(cloudTag);
          }
          if (!newTags.includes("cloud-upload")) {
            newTags.push("cloud-upload");
          }
          await this.api.updateItem(item.id, { tags: newTags });
        }
      } else {
        new import_obsidian5.Notice(`Upload failed: ${result.error}`);
      }
    } else if (directFilePath) {
      const filename = directFilePath.split("/").pop() || "image";
      const ext = getExtFromFilename(filename);
      const mimeType = getMimeType2(ext);
      new import_obsidian5.Notice(`Uploading ${filename} to ${providerName}...`);
      const result = await provider.upload(directFilePath, filename, mimeType);
      if (result.success && result.publicUrl) {
        const markdown = `![${filename}](${result.publicUrl})`;
        editor.replaceSelection(markdown);
        new import_obsidian5.Notice(`Embedded and uploaded to ${providerName}!`);
      } else {
        new import_obsidian5.Notice(`Upload failed: ${result.error}`);
      }
    }
  }
  processActiveView() {
    return;
  }
  tryConvertImagePath(img) {
    const src = img.getAttribute("src");
    if (!src)
      return;
    const alreadyConverted = img.getAttribute("data-original-src");
    if (alreadyConverted)
      return;
    console.log(`[CMDS Eagle] Checking image src: ${src}`);
    let extractedPath = null;
    if (src.startsWith("file://")) {
      extractedPath = this.fullyDecodeUri(src.replace(/^file:\/\/\/?/, ""));
    } else if (src.startsWith("app://")) {
      const appMatch = src.match(/^app:\/\/[^/]+\/(.+)$/);
      if (appMatch) {
        extractedPath = this.fullyDecodeUri(appMatch[1]);
      }
    }
    if (!extractedPath) {
      console.log(`[CMDS Eagle] No extractable path`);
      return;
    }
    console.log(`[CMDS Eagle] Extracted: ${extractedPath}`);
    if (extractedPath.startsWith("Users/") && !extractedPath.startsWith("/")) {
      extractedPath = "/" + extractedPath;
    }
    const isDifferent = this.isPathFromDifferentPlatform(extractedPath);
    console.log(`[CMDS Eagle] Is from different platform: ${isDifferent}`);
    if (!isDifferent)
      return;
    const convertedPath = this.convertPathForCurrentPlatform(extractedPath);
    if (convertedPath !== extractedPath) {
      const newSrc = this.pathToFileUrl(convertedPath);
      console.log(`[CMDS Eagle] Setting new src: ${newSrc}`);
      const newImg = activeDocument.createElement("img");
      newImg.src = newSrc;
      newImg.alt = img.alt;
      newImg.className = img.className;
      newImg.setAttribute("data-original-src", src);
      newImg.setAttribute("data-xplatform-replaced", "true");
      if (img.parentNode) {
        img.parentNode.replaceChild(newImg, img);
        console.log(`[CMDS Eagle] Image element replaced`);
      }
    }
  }
  isPathFromDifferentPlatform(path) {
    const currentPlatform = this.getCurrentPlatform();
    const currentUsername = this.getCurrentUsername();
    for (const computer of this.settings.computers) {
      if (computer.platform === currentPlatform && computer.username === currentUsername) {
        continue;
      }
      if (computer.platform === "darwin") {
        if (path.includes(`/Users/${computer.username}/`)) {
          return true;
        }
      } else if (computer.platform === "win32") {
        const winPattern = new RegExp(`[A-Za-z]:[/\\\\]Users[/\\\\]${computer.username}[/\\\\]`, "i");
        if (winPattern.test(path)) {
          return true;
        }
      }
    }
    return false;
  }
  processEagleLinks(el) {
    const links = el.querySelectorAll('a[href^="eagle://"]');
    links.forEach((link) => {
      const href = link.getAttribute("href");
      if (href) {
        link.addEventListener("click", (e) => {
          e.preventDefault();
          window.open(href);
        });
        link.addClass("cmdspace-eagle-link");
      }
    });
  }
  processFileUrls(el) {
    if (!this.settings.enableCrossPlatform)
      return;
    if (this.settings.crossPlatformConversionMode !== "render-only")
      return;
    const images = el.querySelectorAll("img");
    images.forEach((img) => {
      this.convertImageSrcForRendering(img);
    });
  }
  convertImageSrcForRendering(img) {
    const src = img.getAttribute("src");
    if (!src)
      return;
    if (img.getAttribute("data-xplatform-converted"))
      return;
    let extractedPath = null;
    if (src.startsWith("app://")) {
      const appMatch = src.match(/^app:\/\/[^/]+\/(.+)$/);
      if (appMatch) {
        extractedPath = this.fullyDecodeUri(appMatch[1]);
      }
    } else if (src.startsWith("file://")) {
      extractedPath = this.fullyDecodeUri(src.replace(/^file:\/\/\/?/, ""));
    }
    if (!extractedPath)
      return;
    if (extractedPath.startsWith("Users/") && !extractedPath.startsWith("/")) {
      extractedPath = "/" + extractedPath;
    }
    if (!this.isPathFromDifferentPlatform(extractedPath))
      return;
    const convertedPath = this.convertPathForCurrentPlatform(extractedPath);
    if (convertedPath !== extractedPath) {
      const newSrc = this.pathToFileUrl(convertedPath);
      img.setAttribute("src", newSrc);
      img.setAttribute("data-xplatform-converted", "true");
      img.setAttribute("data-original-src", src);
    }
  }
  fullyDecodeUri(str) {
    let decoded = str;
    try {
      while (decoded.includes("%")) {
        const next = decodeURIComponent(decoded);
        if (next === decoded)
          break;
        decoded = next;
      }
    } catch (e) {
      return str;
    }
    return decoded;
  }
  normalizeTag(tag) {
    let normalized = tag.replace(/\s+/g, "-");
    if (this.settings.tagNormalization === "lowercase") {
      normalized = normalized.toLowerCase();
    }
    if (this.settings.tagPrefix) {
      normalized = `${this.settings.tagPrefix}/${normalized}`;
    }
    return normalized;
  }
  formatFileSize(bytes) {
    if (bytes < 1024)
      return `${bytes} B`;
    if (bytes < 1024 * 1024)
      return `${(bytes / 1024).toFixed(1)} KB`;
    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
  }
  // Synchronous gate for the editor-paste handler. preventDefault() must be
  // called synchronously, so detection happens here before delegating async work.
  willHandlePaste(evt) {
    const clipboardData = evt.clipboardData;
    if (!clipboardData)
      return false;
    const text = clipboardData.getData("text/plain").trim();
    if (isEagleLocalhostUrl(text))
      return true;
    if (this.isEagleLibraryPath(text))
      return true;
    const { files } = clipboardData;
    if (!files || !this.allFilesAreImages(files))
      return false;
    return this.settings.imagePasteBehavior !== "local";
  }
  async handlePaste(evt, editor) {
    const clipboardData = evt.clipboardData;
    if (!clipboardData)
      return;
    const text = clipboardData.getData("text/plain").trim();
    if (isEagleLocalhostUrl(text)) {
      await this.handleEagleLocalhostUrlPaste(text, editor);
      return;
    }
    if (this.isEagleLibraryPath(text)) {
      await this.handleEagleLibraryPathPaste(text, editor);
      return;
    }
    const { files } = clipboardData;
    if (!files || !this.allFilesAreImages(files))
      return;
    if (this.settings.imagePasteBehavior === "local") {
      return;
    }
    const filesCopy = Array.from(files);
    if (this.settings.imagePasteBehavior === "eagle") {
      for (const file of filesCopy) {
        await this.uploadFileWithProgress(file, editor);
      }
      return;
    }
    if (this.settings.imagePasteBehavior === "cloud") {
      for (const file of filesCopy) {
        await this.uploadToCloudWithProgress(file, editor);
      }
      return;
    }
    const cloudProviderName = this.getActiveCloudProviderName();
    const modal = new ImagePasteChoiceModal(this.app, cloudProviderName);
    modal.open();
    const response = await modal.getResponse();
    if (response.rememberChoice && response.choice !== "cancel") {
      this.settings.imagePasteBehavior = response.choice;
      await this.saveSettings();
    }
    if (response.choice === "eagle") {
      for (const file of filesCopy) {
        await this.uploadFileWithProgress(file, editor);
      }
    } else if (response.choice === "local") {
      for (const file of filesCopy) {
        await this.saveImageLocally(file, editor);
      }
    } else if (response.choice === "cloud") {
      for (const file of filesCopy) {
        await this.uploadToCloudWithProgress(file, editor);
      }
    }
  }
  // Synchronous gate for the editor-drop handler (see willHandlePaste).
  willHandleDrop(evt) {
    const { files } = evt.dataTransfer || { files: null };
    if (!files || !this.allFilesAreImages(files))
      return false;
    return this.settings.imagePasteBehavior !== "local";
  }
  async handleDrop(evt, editor) {
    const { files } = evt.dataTransfer || { files: null };
    if (!files || !this.allFilesAreImages(files))
      return;
    if (this.settings.imagePasteBehavior === "local") {
      return;
    }
    const filesCopy = Array.from(files);
    if (this.settings.imagePasteBehavior === "eagle") {
      for (const file of filesCopy) {
        await this.uploadFileWithProgress(file, editor);
      }
      return;
    }
    if (this.settings.imagePasteBehavior === "cloud") {
      for (const file of filesCopy) {
        await this.uploadToCloudWithProgress(file, editor);
      }
      return;
    }
    const cloudProviderName = this.getActiveCloudProviderName();
    const modal = new ImagePasteChoiceModal(this.app, cloudProviderName);
    modal.open();
    const response = await modal.getResponse();
    if (response.rememberChoice && response.choice !== "cancel") {
      this.settings.imagePasteBehavior = response.choice;
      await this.saveSettings();
    }
    if (response.choice === "eagle") {
      for (const file of filesCopy) {
        await this.uploadFileWithProgress(file, editor);
      }
    } else if (response.choice === "local") {
      for (const file of filesCopy) {
        await this.saveImageLocally(file, editor);
      }
    } else if (response.choice === "cloud") {
      for (const file of filesCopy) {
        await this.uploadToCloudWithProgress(file, editor);
      }
    }
  }
  async saveImageLocally(file, editor) {
    var _a, _b, _c;
    const activeFile = this.app.workspace.getActiveFile();
    if (!activeFile) {
      new import_obsidian5.Notice("No active file");
      return;
    }
    try {
      const buffer = await file.arrayBuffer();
      const timestamp = Date.now();
      const filename = `${timestamp}-${file.name}`;
      const vault = this.app.vault;
      const attachmentFolder = ((_a = vault.getConfig) == null ? void 0 : _a.call(vault, "attachmentFolderPath")) || "";
      let targetPath;
      if (attachmentFolder === "./") {
        const parentFolder = ((_b = activeFile.parent) == null ? void 0 : _b.path) || "";
        targetPath = parentFolder ? `${parentFolder}/${filename}` : filename;
      } else if (attachmentFolder.startsWith("./")) {
        const parentFolder = ((_c = activeFile.parent) == null ? void 0 : _c.path) || "";
        const relativeFolder = attachmentFolder.slice(2);
        targetPath = parentFolder ? `${parentFolder}/${relativeFolder}/${filename}` : `${relativeFolder}/${filename}`;
      } else if (attachmentFolder) {
        targetPath = `${attachmentFolder}/${filename}`;
      } else {
        targetPath = filename;
      }
      const folderPath = targetPath.substring(0, targetPath.lastIndexOf("/"));
      if (folderPath) {
        const folderExists = await this.app.vault.adapter.exists(folderPath);
        if (!folderExists) {
          await this.app.vault.createFolder(folderPath);
        }
      }
      await this.app.vault.createBinary(targetPath, buffer);
      const markdownImage = `![${file.name}](${encodeURI(targetPath)})`;
      editor.replaceSelection(markdownImage);
      new import_obsidian5.Notice(`Saved locally: ${file.name}`);
    } catch (error) {
      console.error("Failed to save image locally:", error);
      new import_obsidian5.Notice(`Failed to save: ${file.name}`);
    }
  }
  async uploadFileWithProgress(file, editor) {
    const pasteId = this.generatePasteId();
    const placeholderText = `![Uploading ${file.name}...](${pasteId})`;
    editor.replaceSelection(placeholderText);
    try {
      const imageUrl = await this.uploadImageToEagle(file);
      const markdownImage = `![${file.name}](${imageUrl})`;
      this.replaceTextInDocument(editor, placeholderText, markdownImage);
      new import_obsidian5.Notice(`Uploaded to Eagle: ${file.name}`);
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : "Unknown error";
      const errorText = `<!-- Failed to upload ${file.name}: ${errorMessage} -->`;
      this.replaceTextInDocument(editor, placeholderText, errorText);
      console.error("Failed to upload image:", error);
      new import_obsidian5.Notice(`Failed to upload: ${file.name}`);
    }
  }
  async uploadToCloudWithProgress(file, editor) {
    const provider = this.getActiveCloudProvider();
    if (!provider) {
      new import_obsidian5.Notice("No cloud provider configured");
      return;
    }
    const pasteId = this.generatePasteId();
    const providerName = this.getActiveCloudProviderName();
    const placeholderText = `![Uploading to ${providerName}...](${pasteId})`;
    editor.replaceSelection(placeholderText);
    try {
      const tempPath = await this.saveToTempLocation(file);
      const ext = getExtFromFilename(file.name);
      const mimeType = getMimeType2(ext);
      const result = await provider.upload(tempPath, file.name, mimeType);
      if (result.success && result.publicUrl) {
        const markdownImage = `![${file.name}](${result.publicUrl})`;
        this.replaceTextInDocument(editor, placeholderText, markdownImage);
        new import_obsidian5.Notice(`Uploaded to ${providerName}: ${file.name}`);
      } else {
        throw new Error(result.error || "Upload failed");
      }
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : "Unknown error";
      const errorText = `<!-- Failed to upload ${file.name}: ${errorMessage} -->`;
      this.replaceTextInDocument(editor, placeholderText, errorText);
      console.error("Failed to upload to cloud:", error);
      new import_obsidian5.Notice(`Failed to upload: ${file.name}`);
    }
  }
  getActiveCloudProvider() {
    const providerType = this.settings.activeCloudProvider;
    const config = this.settings.cloudProviders[providerType];
    if (!config || !config.enabled) {
      if (this.settings.r2WorkerUrl && this.settings.r2ApiKey) {
        return createCloudProvider({
          type: "r2",
          enabled: true,
          name: "Cloudflare R2",
          workerUrl: this.settings.r2WorkerUrl,
          apiKey: this.settings.r2ApiKey,
          publicUrl: this.settings.r2PublicUrl
        });
      }
      return null;
    }
    return createCloudProvider(config);
  }
  getActiveCloudProviderName() {
    const providerType = this.settings.activeCloudProvider;
    const config = this.settings.cloudProviders[providerType];
    if ((config == null ? void 0 : config.enabled) && (config == null ? void 0 : config.name)) {
      return config.name;
    }
    if (this.settings.r2WorkerUrl) {
      return "Cloudflare R2";
    }
    return "Cloud";
  }
  replaceTextInDocument(editor, searchText, replaceText) {
    const content = editor.getValue();
    const index = content.indexOf(searchText);
    if (index === -1)
      return;
    const startPos = editor.offsetToPos(index);
    const endPos = editor.offsetToPos(index + searchText.length);
    editor.replaceRange(replaceText, startPos, endPos);
  }
  generatePasteId() {
    return `paste-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
  }
  getLocalImageUnderCursor(editor) {
    const cursor = editor.getCursor();
    const line = editor.getLine(cursor.line);
    const supportedExtensions = ["png", "jpg", "jpeg", "gif", "bmp", "svg", "webp", "tiff", "tif", "heic", "heif", "avif", "ico"];
    const extensionPattern = supportedExtensions.join("|");
    const wikilinkPattern = new RegExp(`!\\[\\[([^\\]]+\\.(${extensionPattern}))\\]\\]`, "gi");
    const markdownPattern = new RegExp(`!\\[([^\\]]*)\\]\\(([^)]+\\.(${extensionPattern}))\\)`, "gi");
    let match;
    wikilinkPattern.lastIndex = 0;
    while ((match = wikilinkPattern.exec(line)) !== null) {
      const start = match.index;
      const end = start + match[0].length;
      if (cursor.ch >= start && cursor.ch <= end) {
        const filename = match[1];
        const file = this.app.metadataCache.getFirstLinkpathDest(filename, "");
        if (file instanceof import_obsidian5.TFile) {
          return {
            file,
            startPos: { line: cursor.line, ch: start },
            endPos: { line: cursor.line, ch: end },
            originalText: match[0]
          };
        }
      }
    }
    markdownPattern.lastIndex = 0;
    while ((match = markdownPattern.exec(line)) !== null) {
      const start = match.index;
      const end = start + match[0].length;
      if (cursor.ch >= start && cursor.ch <= end) {
        const filepath = match[2];
        if (!filepath.startsWith("http") && !filepath.startsWith("file://") && !filepath.startsWith("eagle://")) {
          const file = this.app.metadataCache.getFirstLinkpathDest(filepath, "");
          if (file instanceof import_obsidian5.TFile) {
            return {
              file,
              startPos: { line: cursor.line, ch: start },
              endPos: { line: cursor.line, ch: end },
              originalText: match[0]
            };
          }
        }
      }
    }
    return null;
  }
  async uploadLocalImageToEagle(editor, localImage) {
    const { file, startPos, endPos, originalText } = localImage;
    const placeholderText = `![Uploading ${file.name}...](uploading)`;
    editor.replaceRange(placeholderText, startPos, endPos);
    try {
      const connected = await this.api.isConnected();
      if (!connected) {
        throw new Error("Eagle is not running");
      }
      const absolutePath = this.getAbsolutePath(file.path);
      const filenameWithoutExt = file.basename;
      const result = await this.api.addFromPath({
        path: absolutePath,
        name: filenameWithoutExt,
        folderId: this.settings.defaultFolder || void 0
      });
      if (!result.success || !result.itemId) {
        throw new Error("Failed to add image to Eagle");
      }
      await this.delay(1e3);
      const thumbnailPath = await this.api.getThumbnailPath(result.itemId);
      const imageUrl = thumbnailPath ? `file://${thumbnailPath}` : `eagle://item/${result.itemId}`;
      const markdownImage = `![${file.basename}](${imageUrl})`;
      this.replaceTextInDocument(editor, placeholderText, markdownImage);
      new import_obsidian5.Notice(`Uploaded to Eagle: ${file.name}`);
      await this.offerToReplaceOtherReferences(file, imageUrl, { line: startPos.line, ch: startPos.ch });
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : "Unknown error";
      this.replaceTextInDocument(editor, placeholderText, originalText);
      new import_obsidian5.Notice(`Failed to upload: ${errorMessage}`);
    }
  }
  async offerToReplaceOtherReferences(originalFile, newUrl, excludePosition) {
    const references = this.findAllReferencesToFile(originalFile);
    const filteredRefs = [];
    for (const ref of references) {
      const filteredPositions = ref.positions.filter((pos) => {
        const activeFile = this.app.workspace.getActiveFile();
        if (activeFile && ref.notePath === activeFile.path) {
          return !(pos.line === excludePosition.line && pos.ch === excludePosition.ch);
        }
        return true;
      });
      if (filteredPositions.length > 0) {
        filteredRefs.push({ notePath: ref.notePath, positions: filteredPositions });
      }
    }
    if (filteredRefs.length === 0)
      return;
    const totalCount = filteredRefs.reduce((sum, ref) => sum + ref.positions.length, 0);
    const fileCount = filteredRefs.length;
    const shouldReplace = await this.confirmReplaceReferences(totalCount, fileCount, originalFile.name);
    if (!shouldReplace)
      return;
    await this.replaceAllReferences(filteredRefs, originalFile, newUrl);
    new import_obsidian5.Notice(`Replaced ${totalCount} references in ${fileCount} files`);
  }
  findAllReferencesToFile(targetFile) {
    const results = [];
    const allFiles = this.app.vault.getMarkdownFiles();
    for (const file of allFiles) {
      const cache = this.app.metadataCache.getFileCache(file);
      if (!(cache == null ? void 0 : cache.embeds))
        continue;
      const positions = [];
      for (const embed of cache.embeds) {
        const linkedFile = this.app.metadataCache.getFirstLinkpathDest(embed.link, file.path);
        if (linkedFile === targetFile) {
          positions.push({
            line: embed.position.start.line,
            ch: embed.position.start.col,
            text: embed.original
          });
        }
      }
      if (positions.length > 0) {
        results.push({ notePath: file.path, positions });
      }
    }
    return results;
  }
  async confirmReplaceReferences(count, fileCount, filename) {
    return new Promise((resolve) => {
      const notice = new import_obsidian5.Notice(
        `Found ${count} other references to "${filename}" in ${fileCount} files. Click to replace all with Eagle link.`,
        1e4
      );
      const noticeEl = notice.noticeEl;
      noticeEl.addClass("cmds-eagle-clickable-notice");
      noticeEl.onclick = () => {
        notice.hide();
        resolve(true);
      };
      window.setTimeout(() => resolve(false), 1e4);
    });
  }
  async replaceAllReferences(references, originalFile, newUrl) {
    for (const ref of references) {
      const file = this.app.vault.getAbstractFileByPath(ref.notePath);
      if (!(file instanceof import_obsidian5.TFile))
        continue;
      let content = await this.app.vault.read(file);
      const sortedPositions = [...ref.positions].sort((a, b) => {
        if (a.line !== b.line)
          return b.line - a.line;
        return b.ch - a.ch;
      });
      for (const pos of sortedPositions) {
        const newMarkdown = `![${originalFile.basename}](${newUrl})`;
        const lines = content.split("\n");
        const line = lines[pos.line];
        if (line) {
          const index = line.indexOf(pos.text, pos.ch);
          if (index !== -1) {
            lines[pos.line] = line.substring(0, index) + newMarkdown + line.substring(index + pos.text.length);
            content = lines.join("\n");
          }
        }
      }
      await this.app.vault.modify(file, content);
    }
  }
  async handleEagleLocalhostUrlPaste(url, editor) {
    const itemId = parseEagleLocalhostUrl(url);
    if (!itemId) {
      new import_obsidian5.Notice("Invalid Eagle URL");
      return;
    }
    const item = await this.api.getItemInfo(itemId);
    if (!item) {
      new import_obsidian5.Notice("Could not fetch item info from Eagle");
      return;
    }
    const filePath = await this.getEagleItemFilePath(itemId, item.name, item.ext);
    if (filePath) {
      const fileUrl = this.pathToFileUrl(filePath);
      const filename = `${item.name}.${item.ext}`;
      const markdown = `![${filename}](${fileUrl})`;
      editor.replaceSelection(markdown);
      new import_obsidian5.Notice(`Embedded: ${filename}`);
    } else {
      new import_obsidian5.Notice("Could not get file path from Eagle");
    }
  }
  isEagleLibraryPath(text) {
    if (text.startsWith("![") || text.startsWith("](")) {
      return false;
    }
    const normalizedText = text.replace(/\\/g, "/");
    return normalizedText.includes(".library/images/") && normalizedText.includes(".info/");
  }
  async handleEagleLibraryPathPaste(path, editor) {
    const normalizedPath = this.safeDecodeUri(path.replace(/\\/g, "/")).replace(/^file:\/\/+/, "/");
    const idMatch = normalizedPath.match(/\/([A-Za-z0-9]+)\.info\//);
    if (idMatch) {
      const item = await this.api.getItemInfo(idMatch[1]);
      if (item) {
        const folderPath = normalizedPath.substring(0, normalizedPath.lastIndexOf("/"));
        const originalPath = `${folderPath}/${item.name}.${item.ext}`;
        const filename2 = `${item.name}.${item.ext}`;
        editor.replaceSelection(`![${filename2}](${this.pathToFileUrl(originalPath)})`);
        new import_obsidian5.Notice(`Embedded: ${filename2}`);
        return;
      }
    }
    const fallbackPath = normalizedPath.replace(/_thumbnail(\.[A-Za-z0-9]+)$/, "$1");
    const filename = fallbackPath.split("/").pop() || "image";
    editor.replaceSelection(`![${filename}](${this.pathToFileUrl(fallbackPath)})`);
    new import_obsidian5.Notice(`Embedded: ${filename}`);
  }
  async getEagleItemFilePath(itemId, name, ext) {
    const thumbnailPath = await this.api.getThumbnailPath(itemId);
    if (!thumbnailPath)
      return null;
    const decodedPath = this.safeDecodeUri(thumbnailPath);
    const folderPath = decodedPath.substring(0, decodedPath.lastIndexOf("/"));
    const originalFileName = `${name}.${ext}`;
    return `${folderPath}/${originalFileName}`;
  }
  // ── Excalidraw integration ──────────────────────────────────────────────
  // Obsidian's editor-paste/editor-drop events only fire in the Markdown editor,
  // not in an Excalidraw canvas. And the Excalidraw plugin's onPasteHook receives
  // an already-consumed clipboard (no image bytes). So we attach capture-phase
  // paste/drop listeners on each Excalidraw view container: this intercepts BEFORE
  // Excalidraw, handles Eagle references (embed the ORIGINAL) and pasted image
  // files (upload to the cloud provider), and suppresses Excalidraw's default
  // handling — embedding a portable cloud URL instead of a vault attachment.
  registerExcalidrawIntegration() {
    this.app.workspace.onLayoutReady(() => {
      this.scanAndAttachExcalidrawContainers();
      this.registerEvent(this.app.workspace.on("active-leaf-change", () => {
        this.scanAndAttachExcalidrawContainers();
      }));
      this.registerEvent(this.app.workspace.on("layout-change", () => {
        this.scanAndAttachExcalidrawContainers();
      }));
    });
  }
  // Public so the settings toggle can attach to already-open canvases immediately.
  scanAndAttachExcalidrawContainers() {
    if (!this.settings.excalidrawIntegration)
      return;
    for (const leaf of this.app.workspace.getLeavesOfType("excalidraw")) {
      const view = leaf.view;
      const el = view == null ? void 0 : view.containerEl;
      if (!el || this.attachedExcalidrawContainers.has(el) || typeof view.addImageWithURL !== "function")
        continue;
      this.attachedExcalidrawContainers.add(el);
      this.registerDomEvent(el, "paste", (evt) => this.onExcalidrawPasteOrDrop(evt, view), { capture: true });
      this.registerDomEvent(el, "drop", (evt) => this.onExcalidrawPasteOrDrop(evt, view), { capture: true });
    }
  }
  onExcalidrawPasteOrDrop(evt, view) {
    if (!this.settings.excalidrawIntegration)
      return;
    const dt = evt instanceof ClipboardEvent ? evt.clipboardData : evt.dataTransfer;
    if (!dt)
      return;
    const text = (dt.getData("text/plain") || "").trim();
    if (this.isEagleReference(text)) {
      evt.preventDefault();
      evt.stopImmediatePropagation();
      void this.addEagleRefToCanvas(view, text);
      return;
    }
    const images = Array.from(dt.files).filter((f) => f.type.startsWith("image/"));
    if (images.length > 0) {
      evt.preventDefault();
      evt.stopImmediatePropagation();
      void this.addImageFilesToCanvas(view, images);
      return;
    }
  }
  isEagleReference(text) {
    return !!text && (isEagleLocalhostUrl(text) || this.isEagleLibraryPath(text));
  }
  async resolveEagleItemFromReference(text) {
    if (isEagleLocalhostUrl(text)) {
      const id = parseEagleLocalhostUrl(text);
      return id ? this.api.getItemInfo(id) : null;
    }
    const idMatch = text.replace(/\\/g, "/").match(/\/([A-Za-z0-9]+)\.info\//);
    return idMatch ? this.api.getItemInfo(idMatch[1]) : null;
  }
  async getEaglePublicUrl(item) {
    const existing = this.api.getCloudUrl(item);
    if (existing)
      return existing;
    const provider = this.getActiveCloudProvider();
    if (!provider) {
      new import_obsidian5.Notice("No cloud provider configured for Excalidraw embed");
      return null;
    }
    const originalPath = await this.api.getOriginalFilePath(item);
    if (!originalPath)
      return null;
    const result = await provider.upload(originalPath, `${item.name}.${item.ext}`, getMimeType2(item.ext));
    return result.success && result.publicUrl ? result.publicUrl : null;
  }
  async addEagleRefToCanvas(view, text) {
    try {
      const item = await this.resolveEagleItemFromReference(text);
      if (!item) {
        new import_obsidian5.Notice("Could not fetch item info from Eagle");
        return;
      }
      const url = await this.getEaglePublicUrl(item);
      if (!url) {
        new import_obsidian5.Notice(`Could not get a cloud URL for ${item.name}`);
        return;
      }
      await view.addImageWithURL(url);
      new import_obsidian5.Notice(`Added to canvas: ${item.name}.${item.ext}`);
    } catch (error) {
      console.error("[CMDS Eagle] Excalidraw Eagle-ref embed failed:", error);
      new import_obsidian5.Notice("Failed to add Eagle image to Excalidraw canvas");
    }
  }
  async addImageFilesToCanvas(view, files) {
    const provider = this.getActiveCloudProvider();
    if (!provider) {
      new import_obsidian5.Notice("No cloud provider configured for Excalidraw embed");
      return;
    }
    const providerName = this.getActiveCloudProviderName();
    for (const file of files) {
      try {
        const tempPath = await this.saveToTempLocation(file);
        let eagleNote = "";
        if (this.settings.excalidrawImportToEagle) {
          const added = await this.api.addFromPath({
            path: tempPath,
            name: file.name.replace(/\.[^.]+$/, ""),
            folderId: this.settings.defaultFolder || void 0
          });
          if (added.success)
            eagleNote = " + Eagle";
        }
        const result = await provider.upload(tempPath, file.name, getMimeType2(getExtFromFilename(file.name)));
        if (result.success && result.publicUrl) {
          await view.addImageWithURL(result.publicUrl);
          new import_obsidian5.Notice(`Uploaded to ${providerName}${eagleNote} & added to canvas: ${file.name}`);
        } else {
          new import_obsidian5.Notice(`Failed to upload ${file.name}`);
        }
      } catch (error) {
        console.error("[CMDS Eagle] Excalidraw image upload failed:", error);
        new import_obsidian5.Notice(`Failed to add image to Excalidraw canvas: ${file.name}`);
      }
    }
  }
  safeDecodeUri(str) {
    try {
      return decodeURIComponent(str);
    } catch (e) {
      return str;
    }
  }
  pathToFileUrl(path) {
    let decodedPath = path;
    try {
      while (decodedPath.includes("%")) {
        const decoded = decodeURIComponent(decodedPath);
        if (decoded === decodedPath)
          break;
        decodedPath = decoded;
      }
    } catch (e) {
      decodedPath = path;
    }
    const convertedPath = this.convertPathForCurrentPlatform(decodedPath);
    const normalizedPath = convertedPath.replace(/\\/g, "/");
    const encodedPath = normalizedPath.split("/").map((segment) => encodeURIComponent(segment)).join("/");
    if (this.getCurrentPlatform() === "win32" && /^[A-Za-z]:/.test(normalizedPath)) {
      const fixedPath = encodedPath.replace(/^([A-Za-z])%3A/, "$1:");
      return `file:///${fixedPath}`;
    }
    return `file://${encodedPath}`;
  }
  getCurrentPlatform() {
    return process.platform;
  }
  getCurrentUsername() {
    const platform = this.getCurrentPlatform();
    const vaultPath = this.getVaultPath();
    if (platform === "darwin") {
      const match = vaultPath.match(/^\/Users\/([^/]+)/);
      if (match)
        return match[1];
    } else if (platform === "win32") {
      const match = vaultPath.match(/^[A-Za-z]:[/\\]Users[/\\]([^/\\]+)/i);
      if (match)
        return match[1];
    }
    return "";
  }
  findMatchingComputer(path) {
    if (!this.settings.enableCrossPlatform || this.settings.computers.length === 0) {
      return null;
    }
    for (const computer of this.settings.computers) {
      if (computer.platform === "darwin") {
        const macPattern = `/Users/${computer.username}/`;
        if (path.includes(macPattern)) {
          return computer;
        }
      } else if (computer.platform === "win32") {
        const winPattern = new RegExp(`^[A-Za-z]:[/\\\\]Users[/\\\\]${computer.username}[/\\\\]`, "i");
        if (winPattern.test(path)) {
          return computer;
        }
      }
    }
    console.log("[CMDS Eagle] No computer matched path:", path.substring(0, 50));
    return null;
  }
  convertPathForCurrentPlatform(path) {
    if (!this.settings.enableCrossPlatform || this.settings.computers.length === 0) {
      return path;
    }
    const sourceComputer = this.findMatchingComputer(path);
    if (!sourceComputer) {
      console.log("[CMDS Eagle] No matching computer found for path");
      return path;
    }
    const currentPlatform = this.getCurrentPlatform();
    const currentUsername = this.getCurrentUsername();
    const currentComputer = this.settings.computers.find(
      (c) => c.platform === currentPlatform && c.username === currentUsername
    );
    if (!currentComputer || sourceComputer.id === currentComputer.id) {
      return path;
    }
    const sourceSubPath = sourceComputer.subPath || "";
    const currentSubPath = currentComputer.subPath || "";
    console.log(`[CMDS Eagle] Converting: ${sourceComputer.platform}/${sourceComputer.username}/${sourceSubPath} \u2192 ${currentComputer.platform}/${currentComputer.username}/${currentSubPath}`);
    let relativePath = "";
    if (sourceComputer.platform === "darwin") {
      const sourceRoot = sourceSubPath ? `/Users/${sourceComputer.username}/${sourceSubPath}/` : `/Users/${sourceComputer.username}/`;
      relativePath = path.replace(sourceRoot, "");
    } else {
      const subPathPart = sourceSubPath ? `[/\\\\]${sourceSubPath.replace(/[/\\]/g, "[/\\\\]")}` : "";
      const winPattern = new RegExp(`[A-Za-z]:[/\\\\]Users[/\\\\]${sourceComputer.username}${subPathPart}[/\\\\]`, "i");
      relativePath = path.replace(winPattern, "").replace(/\\/g, "/");
    }
    if (currentComputer.platform === "darwin") {
      const targetRoot = currentSubPath ? `/Users/${currentComputer.username}/${currentSubPath}/` : `/Users/${currentComputer.username}/`;
      return `${targetRoot}${relativePath}`;
    } else {
      const targetRoot = currentSubPath ? `C:/Users/${currentComputer.username}/${currentSubPath}/` : `C:/Users/${currentComputer.username}/`;
      return `${targetRoot}${relativePath}`;
    }
  }
  async uploadImageToEagle(file) {
    const tempPath = await this.saveToTempLocation(file);
    const connected = await this.api.isConnected();
    if (!connected) {
      throw new Error("Eagle is not running");
    }
    const filenameWithoutExt = file.name.replace(/\.[^.]+$/, "");
    const result = await this.api.addFromPath({
      path: tempPath,
      name: filenameWithoutExt,
      folderId: this.settings.defaultFolder || void 0
    });
    if (!result.success || !result.itemId) {
      throw new Error("Failed to add image to Eagle");
    }
    await this.delay(1e3);
    const thumbnailPath = await this.api.getThumbnailPath(result.itemId);
    return thumbnailPath ? `file://${thumbnailPath}` : `file://${tempPath}`;
  }
  async saveToTempLocation(file) {
    const tempDir = ".eagle-temp";
    const tempDirPath = `${tempDir}`;
    const adapter = this.app.vault.adapter;
    const tempDirExists = await adapter.exists(tempDirPath);
    if (!tempDirExists) {
      await adapter.mkdir(tempDirPath);
    }
    const timestamp = Date.now();
    const filename = `${timestamp}-${file.name}`;
    const tempFilePath = `${tempDirPath}/${filename}`;
    const buffer = await file.arrayBuffer();
    const uint8Array = new Uint8Array(buffer);
    await adapter.writeBinary(tempFilePath, uint8Array);
    return this.getAbsolutePath(tempFilePath);
  }
  getVaultPath() {
    const adapter = this.app.vault.adapter;
    if (adapter.basePath) {
      return adapter.basePath;
    }
    const configDir = this.app.vault.configDir;
    const sep = configDir.lastIndexOf("/");
    return sep > 0 ? configDir.slice(0, sep) : configDir;
  }
  getAbsolutePath(relativePath) {
    const vaultPath = this.getVaultPath();
    if (relativePath.startsWith("/")) {
      return relativePath;
    }
    return `${vaultPath}/${relativePath}`;
  }
  delay(ms) {
    return new Promise((resolve) => window.setTimeout(resolve, ms));
  }
  allFilesAreImages(files) {
    if (!files || files.length === 0)
      return false;
    const imageTypes = [
      "image/jpeg",
      "image/jpg",
      "image/png",
      "image/gif",
      "image/webp",
      "image/bmp",
      "image/svg+xml",
      "image/tiff",
      "image/heic",
      "image/heif",
      "image/avif"
    ];
    for (const file of Array.from(files)) {
      if (!imageTypes.includes(file.type)) {
        return false;
      }
    }
    return true;
  }
  async convertCrossPlatformPaths() {
    if (!this.settings.enableCrossPlatform) {
      new import_obsidian5.Notice("Cross-platform sync is disabled in settings");
      return;
    }
    const activeFile = this.app.workspace.getActiveFile();
    if (!activeFile) {
      new import_obsidian5.Notice("No active file");
      return;
    }
    const content = await this.app.vault.read(activeFile);
    let newContent = content;
    let convertedCount = 0;
    const fileUrlRegex = /!\[([^\]]*)\]\((file:\/\/[^)]+)\)/g;
    let match;
    while ((match = fileUrlRegex.exec(content)) !== null) {
      const originalUrl = match[2];
      let filePath = this.fullyDecodeUri(originalUrl.replace(/^file:\/\/\/?/, ""));
      if (filePath.startsWith("Users/") && !filePath.startsWith("/")) {
        filePath = "/" + filePath;
      }
      if (this.isPathFromDifferentPlatform(filePath)) {
        const convertedPath = this.convertPathForCurrentPlatform(filePath);
        const newUrl = this.pathToFileUrl(convertedPath);
        newContent = newContent.replace(originalUrl, newUrl);
        convertedCount++;
      }
    }
    if (convertedCount > 0) {
      await this.app.vault.modify(activeFile, newContent);
      new import_obsidian5.Notice(`Converted ${convertedCount} cross-platform image paths`);
    } else {
      new import_obsidian5.Notice("No cross-platform paths found to convert");
    }
  }
  async autoConvertOnFileOpen(file) {
    const content = await this.app.vault.read(file);
    let newContent = content;
    let convertedCount = 0;
    const fileUrlRegex = /!\[([^\]]*)\]\((file:\/\/[^)]+)\)/g;
    let match;
    while ((match = fileUrlRegex.exec(content)) !== null) {
      const originalUrl = match[2];
      let filePath = this.fullyDecodeUri(originalUrl.replace(/^file:\/\/\/?/, ""));
      if (filePath.startsWith("Users/") && !filePath.startsWith("/")) {
        filePath = "/" + filePath;
      }
      if (this.isPathFromDifferentPlatform(filePath)) {
        const convertedPath = this.convertPathForCurrentPlatform(filePath);
        const newUrl = this.pathToFileUrl(convertedPath);
        newContent = newContent.replace(originalUrl, newUrl);
        convertedCount++;
      }
    }
    if (convertedCount > 0) {
      await this.app.vault.modify(file, newContent);
      new import_obsidian5.Notice(`Auto-converted ${convertedCount} cross-platform paths`);
    }
  }
  async convertCrossPlatformRenderOnly() {
    if (!this.settings.enableCrossPlatform) {
      new import_obsidian5.Notice("Cross-platform sync is disabled in settings");
      return;
    }
    const view = this.app.workspace.getActiveViewOfType(import_obsidian5.MarkdownView);
    if (!view) {
      new import_obsidian5.Notice("No active markdown view");
      return;
    }
    const allContainers = [
      view.contentEl,
      view.containerEl,
      activeDocument.querySelector(".workspace-leaf.mod-active .view-content"),
      activeDocument.querySelector(".workspace-leaf.mod-active .markdown-preview-view"),
      activeDocument.querySelector(".workspace-leaf.mod-active .cm-content")
    ].filter(Boolean);
    let convertedCount = 0;
    const processedSrcs = /* @__PURE__ */ new Set();
    for (const container of allContainers) {
      const images = container.querySelectorAll("img");
      console.log(`[CMDS Eagle] Found ${images.length} images in container`);
      images.forEach((img) => {
        const src = img.getAttribute("src");
        if (!src)
          return;
        if (processedSrcs.has(src))
          return;
        if (img.getAttribute("data-xplatform-converted"))
          return;
        console.log(`[CMDS Eagle] Processing image src: ${src.substring(0, 80)}`);
        let extractedPath = null;
        if (src.startsWith("app://")) {
          const appMatch = src.match(/^app:\/\/[^/]+\/(.+)$/);
          if (appMatch) {
            extractedPath = this.fullyDecodeUri(appMatch[1]);
            console.log(`[CMDS Eagle] Extracted from app://: ${extractedPath == null ? void 0 : extractedPath.substring(0, 60)}`);
          }
        } else if (src.startsWith("file://")) {
          extractedPath = this.fullyDecodeUri(src.replace(/^file:\/\/\/?/, ""));
          console.log(`[CMDS Eagle] Extracted from file://: ${extractedPath == null ? void 0 : extractedPath.substring(0, 60)}`);
        }
        if (!extractedPath) {
          console.log(`[CMDS Eagle] Could not extract path from: ${src.substring(0, 50)}`);
          return;
        }
        if (extractedPath.startsWith("Users/") && !extractedPath.startsWith("/")) {
          extractedPath = "/" + extractedPath;
        }
        if (!this.isPathFromDifferentPlatform(extractedPath)) {
          console.log(`[CMDS Eagle] Path not from different platform`);
          return;
        }
        const convertedPath = this.convertPathForCurrentPlatform(extractedPath);
        if (convertedPath !== extractedPath) {
          const newSrc = this.pathToFileUrl(convertedPath);
          console.log(`[CMDS Eagle] Converting: ${src.substring(0, 40)} \u2192 ${newSrc.substring(0, 40)}`);
          img.setAttribute("src", newSrc);
          img.setAttribute("data-xplatform-converted", "true");
          img.setAttribute("data-original-src", src);
          processedSrcs.add(src);
          convertedCount++;
        }
      });
    }
    if (convertedCount > 0) {
      new import_obsidian5.Notice(`Render-only: converted ${convertedCount} image paths (source unchanged)`);
    } else {
      new import_obsidian5.Notice("No cross-platform paths found to convert");
    }
  }
  async autoConvertRenderOnlyOnFileOpen() {
    const view = this.app.workspace.getActiveViewOfType(import_obsidian5.MarkdownView);
    if (!view)
      return;
    const contentEl = view.contentEl;
    const images = contentEl.querySelectorAll("img");
    let convertedCount = 0;
    images.forEach((img) => {
      const src = img.getAttribute("src");
      if (!src)
        return;
      if (img.getAttribute("data-xplatform-converted"))
        return;
      let extractedPath = null;
      if (src.startsWith("app://")) {
        const appMatch = src.match(/^app:\/\/[^/]+\/(.+)$/);
        if (appMatch) {
          extractedPath = this.fullyDecodeUri(appMatch[1]);
        }
      } else if (src.startsWith("file://")) {
        extractedPath = this.fullyDecodeUri(src.replace(/^file:\/\/\/?/, ""));
      }
      if (!extractedPath)
        return;
      if (extractedPath.startsWith("Users/") && !extractedPath.startsWith("/")) {
        extractedPath = "/" + extractedPath;
      }
      if (!this.isPathFromDifferentPlatform(extractedPath))
        return;
      const convertedPath = this.convertPathForCurrentPlatform(extractedPath);
      if (convertedPath !== extractedPath) {
        const newSrc = this.pathToFileUrl(convertedPath);
        img.setAttribute("src", newSrc);
        img.setAttribute("data-xplatform-converted", "true");
        img.setAttribute("data-original-src", src);
        convertedCount++;
      }
    });
    if (convertedCount > 0) {
      console.log(`[CMDS Eagle] Auto render-only: converted ${convertedCount} paths`);
    }
  }
  async uploadAllImagesToCloud() {
    const provider = this.getActiveCloudProvider();
    if (!provider) {
      new import_obsidian5.Notice("No cloud provider configured. Check settings.");
      return;
    }
    const activeFile = this.app.workspace.getActiveFile();
    if (!activeFile) {
      new import_obsidian5.Notice("No active file");
      return;
    }
    const content = await this.app.vault.read(activeFile);
    const providerName = this.getActiveCloudProviderName();
    const imageMatches = [];
    const fileUrlRegex = /!\[([^\]]*)\]\((file:\/\/[^)]+)\)/gi;
    let match;
    while ((match = fileUrlRegex.exec(content)) !== null) {
      const url = match[2];
      const filePath = decodeURIComponent(url.replace("file://", ""));
      imageMatches.push({
        full: match[0],
        alt: match[1],
        url,
        filePath
      });
    }
    const localhostRegex = /!\[([^\]]*)\]\((https?:\/\/localhost:\d+\/api\/item\/thumbnail\?id=([A-Z0-9]+))\)/gi;
    while ((match = localhostRegex.exec(content)) !== null) {
      const itemId = match[3];
      const item = await this.api.getItemInfo(itemId);
      if (item) {
        const filePath = await this.api.getOriginalFilePath(item);
        if (filePath) {
          imageMatches.push({
            full: match[0],
            alt: match[1],
            url: match[2],
            filePath
          });
        }
      }
    }
    const localImageRegex = /!\[([^\]]*)\]\((?!https?:\/\/|file:\/\/)([^)]+\.(jpg|jpeg|png|gif|webp|bmp|svg|tiff|tif|heic|heif|avif|ico|mp4|mov))\)/gi;
    while ((match = localImageRegex.exec(content)) !== null) {
      const relativePath = match[2];
      const absolutePath = this.getAbsolutePath(relativePath);
      imageMatches.push({
        full: match[0],
        alt: match[1],
        url: relativePath,
        filePath: absolutePath
      });
    }
    if (imageMatches.length === 0) {
      new import_obsidian5.Notice("No local images found in current note");
      return;
    }
    new import_obsidian5.Notice(`Found ${imageMatches.length} images. Uploading to ${providerName}...`);
    let uploaded = 0;
    let newContent = content;
    for (const img of imageMatches) {
      if (!img.filePath)
        continue;
      if (img.url.startsWith("http://") || img.url.startsWith("https://")) {
        if (!img.url.includes("localhost"))
          continue;
      }
      const filename = img.filePath.split("/").pop() || "image";
      const ext = getExtFromFilename(filename);
      const mimeType = getMimeType2(ext);
      try {
        const result = await provider.upload(img.filePath, filename, mimeType);
        if (result.success && result.publicUrl) {
          newContent = newContent.replace(img.url, result.publicUrl);
          uploaded++;
        }
      } catch (error) {
        console.error(`Failed to upload ${filename}:`, error);
      }
    }
    if (newContent !== content) {
      await this.app.vault.modify(activeFile, newContent);
    }
    new import_obsidian5.Notice(`Uploaded ${uploaded}/${imageMatches.length} images to ${providerName}`);
  }
};