1var __defProp = Object.defineProperty;
2var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
3var __getOwnPropNames = Object.getOwnPropertyNames;
4var __hasOwnProp = Object.prototype.hasOwnProperty;
5var __export = (target, all) => {
6  for (var name in all)
7    __defProp(target, name, { get: all[name], enumerable: true });
8};
9var __copyProps = (to, from, except, desc) => {
10  if (from && typeof from === "object" || typeof from === "function") {
11    for (let key of __getOwnPropNames(from))
12      if (!__hasOwnProp.call(to, key) && key !== except)
13        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
14  }
15  return to;
16};
17var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
18
19// src/main.ts
20var main_exports = {};
21__export(main_exports, {
22  default: () => SublimatedPlugin
23});
24module.exports = __toCommonJS(main_exports);
25var import_obsidian6 = require("obsidian");
26
27// src/settings.ts
28var import_obsidian2 = require("obsidian");
29
30// src/api.ts
31var import_obsidian = require("obsidian");
32var API_BASE = "https://api.sublimated.com";
33var AuthRequiredError = class extends Error {
34  constructor(status) {
35    super(`auth required (${status})`);
36    this.status = status;
37    this.name = "AuthRequiredError";
38  }
39};
40var SublimatedApi = class {
41  constructor(token) {
42    this.token = token;
43  }
44  async request(path) {
45    const headers = {
46      Accept: "application/json"
47    };
48    if (this.token) {
49      headers.Authorization = `Bearer ${this.token}`;
50    }
51    const response = await (0, import_obsidian.requestUrl)({
52      url: `${API_BASE}${path}`,
53      headers,
54      throw: false
55    });
56    if (response.status === 401 || response.status === 403) {
57      throw new AuthRequiredError(response.status);
58    }
59    if (response.status >= 400) {
60      throw new Error(
61        `API error ${response.status}: ${response.text}`
62      );
63    }
64    const body = response.json;
65    if (!body.ok || body.data === void 0) {
66      const msg = body.error?.message || body.error?.type || "unknown error";
67      throw new Error(`API error: ${msg}`);
68    }
69    return body.data;
70  }
71  async getVersions(spaceSlug, itemId) {
72    const raw = await this.request(
73      `/v1/spaces/${encodeURIComponent(spaceSlug)}/items/${encodeURIComponent(itemId)}/versions`
74    );
75    return raw.map(mapVersion).reverse();
76  }
77  async testConnection() {
78    try {
79      const data = await this.request(
80        "/v1/me"
81      );
82      return { ok: true, username: data.username };
83    } catch (e) {
84      return {
85        ok: false,
86        error: e instanceof Error ? e.message : "Unknown error"
87      };
88    }
89  }
90};
91function mapVersion(r) {
92  const author = r.actors.find((a) => a.role === "author") ?? r.actors[0] ?? null;
93  return {
94    id: r.id,
95    number: r.version,
96    authorName: author?.name ?? author?.username ?? "unknown",
97    authorType: author?.actor_type ?? "person",
98    message: r.message,
99    createdAt: r.created_at
100  };
101}
102
103// src/settings.ts
104var DEFAULT_SETTINGS = {
105  apiToken: "",
106  hasSeenWelcome: false
107};
108var SublimatedSettingTab = class extends import_obsidian2.PluginSettingTab {
109  plugin;
110  constructor(app, plugin) {
111    super(app, plugin);
112    this.plugin = plugin;
113  }
114  display() {
115    const { containerEl } = this;
116    containerEl.empty();
117    const header = containerEl.createDiv({ cls: "sbl-settings-header" });
118    header.createEl("h2", { text: "sublimated" });
119    header.createEl("p", {
120      text: "Sync status, version history, and deep links.",
121      cls: "setting-item-description"
122    });
123    const workspaceInfo = this.plugin.detectWorkspace();
124    if (workspaceInfo) {
125      new import_obsidian2.Setting(containerEl).setName("Detected workspace").setDesc(
126        `Space: ${workspaceInfo.space || "unknown"}`
127      );
128    } else {
129      new import_obsidian2.Setting(containerEl).setName("No sublimated file open").setDesc(
130        "Open any synced file from a sublimated folder to see workspace info."
131      );
132    }
133    new import_obsidian2.Setting(containerEl).setName("API token").setDesc(
134      "Required for version history. Generate at sublimated.com/settings/tokens"
135    ).addText(
136      (text) => text.setPlaceholder("sk_...").setValue(this.plugin.settings.apiToken).onChange(async (value) => {
137        this.plugin.settings.apiToken = value;
138        await this.plugin.saveSettings();
139      })
140    );
141    new import_obsidian2.Setting(containerEl).setName("Test connection").setDesc("Verify your API token works").addButton(
142      (btn) => btn.setButtonText("Test").onClick(async () => {
143        if (!this.plugin.settings.apiToken) {
144          new import_obsidian2.Notice("No API token configured");
145          return;
146        }
147        btn.setButtonText("Testing...");
148        btn.setDisabled(true);
149        const api = new SublimatedApi(
150          this.plugin.settings.apiToken
151        );
152        const result = await api.testConnection();
153        if (result.ok) {
154          new import_obsidian2.Notice(
155            `Connected as ${result.username}`
156          );
157        } else {
158          new import_obsidian2.Notice(
159            `Connection failed: ${result.error}`
160          );
161        }
162        btn.setButtonText("Test");
163        btn.setDisabled(false);
164      })
165    );
166    containerEl.createEl("div", { cls: "sbl-settings-links" }, (el) => {
167      el.createEl("a", {
168        text: "sublimated.com",
169        href: "https://sublimated.com"
170      });
171      el.createEl("span", { text: " \xB7 " });
172      el.createEl("a", {
173        text: "Documentation",
174        href: "https://sublimated.com/docs/obsidian"
175      });
176      el.createEl("span", { text: " \xB7 " });
177      el.createEl("a", {
178        text: "Source code",
179        href: "https://sublimated.com/sublimated/code/obsidian"
180      });
181    });
182  }
183};
184
185// src/xattr.ts
186var import_child_process = require("child_process");
187var import_obsidian3 = require("obsidian");
188var XATTR_PREFIX = "com.sublimated.";
189var XATTR_SUFFIX = "#PS";
190var ATTRS = [
191  "version",
192  "commit",
193  "url",
194  "contentHash",
195  "id",
196  "createdBy",
197  "modifiedBy",
198  "modifiedByType",
199  "syncStatus",
200  "space",
201  "branch",
202  "modifiedAt",
203  "visibility"
204];
205function attrToXattrName(attr) {
206  const kebab = attr.replace(/[A-Z]/g, (c) => "-" + c.toLowerCase());
207  return `${XATTR_PREFIX}${kebab}${XATTR_SUFFIX}`;
208}
209function readXattr(path, xattrName) {
210  return new Promise((resolve) => {
211    (0, import_child_process.exec)(
212      `xattr -p ${JSON.stringify(xattrName)} ${JSON.stringify(path)}`,
213      { timeout: 2e3 },
214      (err, stdout) => {
215        if (err) {
216          resolve(null);
217          return;
218        }
219        resolve(stdout.trim() || null);
220      }
221    );
222  });
223}
224async function readFileMetadata(path) {
225  if (!import_obsidian3.Platform.isMacOS) return null;
226  const results = await Promise.all(
227    ATTRS.map((attr) => readXattr(path, attrToXattrName(attr)))
228  );
229  if (results.every((r) => r === null)) return null;
230  const meta = {
231    version: null,
232    commit: null,
233    url: null,
234    contentHash: null,
235    id: null,
236    createdBy: null,
237    modifiedBy: null,
238    modifiedByType: null,
239    syncStatus: null,
240    space: null,
241    branch: null,
242    modifiedAt: null,
243    visibility: null
244  };
245  ATTRS.forEach((attr, i) => {
246    meta[attr] = results[i];
247  });
248  return meta;
249}
250function isMacOS() {
251  return import_obsidian3.Platform.isMacOS;
252}
253
254// src/version-view.ts
255var import_obsidian4 = require("obsidian");
256var VERSION_VIEW_TYPE = "sublimated-versions";
257var VersionView = class extends import_obsidian4.ItemView {
258  plugin;
259  constructor(leaf, plugin) {
260    super(leaf);
261    this.plugin = plugin;
262  }
263  getViewType() {
264    return VERSION_VIEW_TYPE;
265  }
266  getDisplayText() {
267    return "sublimated versions";
268  }
269  getIcon() {
270    return "history";
271  }
272  async onOpen() {
273    await this.refresh();
274    this.registerEvent(
275      this.app.workspace.on("active-leaf-change", () => {
276        this.refresh();
277      })
278    );
279  }
280  async refresh() {
281    const { contentEl } = this;
282    contentEl.empty();
283    contentEl.addClass("sbl-version-view");
284    const activeFile = this.app.workspace.getActiveFile();
285    if (!activeFile) {
286      contentEl.createEl("p", {
287        text: "No file open.",
288        cls: "sbl-version-empty"
289      });
290      return;
291    }
292    const meta = this.plugin.lastMetadata;
293    if (!meta?.space || !meta?.id) {
294      contentEl.createEl("p", {
295        text: "Not a sublimated file.",
296        cls: "sbl-version-empty"
297      });
298      return;
299    }
300    contentEl.createEl("h4", {
301      text: activeFile.name,
302      cls: "sbl-version-filename"
303    });
304    const loading = contentEl.createEl("p", {
305      text: "Loading versions...",
306      cls: "sbl-version-loading"
307    });
308    try {
309      const api = new SublimatedApi(this.plugin.settings.apiToken);
310      const versions = await api.getVersions(meta.space, meta.id);
311      loading.remove();
312      if (versions.length === 0) {
313        contentEl.createEl("p", {
314          text: "No versions found.",
315          cls: "sbl-version-empty"
316        });
317        return;
318      }
319      const list = contentEl.createEl("div", {
320        cls: "sbl-version-list"
321      });
322      const groups = groupByDay(versions);
323      for (const group of groups) {
324        list.createEl("div", {
325          text: group.label,
326          cls: "sbl-version-day"
327        });
328        for (const v of group.versions) {
329          this.renderVersion(list, v, meta.url);
330        }
331      }
332    } catch (e) {
333      loading.remove();
334      if (e instanceof AuthRequiredError) {
335        contentEl.createEl("p", {
336          text: "This file is private \u2014 add an API token to view version history.",
337          cls: "sbl-version-empty"
338        });
339        contentEl.createEl("p", {
340          text: "Configure in Settings \u2192 sublimated",
341          cls: "sbl-version-hint"
342        });
343        return;
344      }
345      contentEl.createEl("p", {
346        text: `Error: ${e instanceof Error ? e.message : "Unknown"}`,
347        cls: "sbl-version-error"
348      });
349    }
350  }
351  renderVersion(container, v, fileUrl) {
352    const item = container.createDiv({ cls: "sbl-version-item" });
353    const header = item.createDiv({ cls: "sbl-version-header" });
354    header.createEl("span", {
355      text: `v${v.number}`,
356      cls: "sbl-version-number"
357    });
358    header.createEl("span", {
359      text: v.authorName,
360      cls: "sbl-version-author"
361    });
362    const time = item.createDiv({ cls: "sbl-version-time" });
363    time.createEl("span", {
364      text: formatRelativeTime(v.createdAt),
365      attr: { title: new Date(v.createdAt).toLocaleString() }
366    });
367    if (v.message) {
368      item.createDiv({
369        text: v.message,
370        cls: "sbl-version-message"
371      });
372    }
373    if (fileUrl) {
374      const webUrl = `https://${fileUrl}/~versions/v${v.number}`;
375      const link = item.createEl("a", {
376        text: "view on web",
377        cls: "sbl-version-web-link",
378        href: webUrl
379      });
380      link.addEventListener("click", (e) => {
381        e.preventDefault();
382        window.open(webUrl);
383      });
384    }
385  }
386  async onClose() {
387  }
388};
389function groupByDay(versions) {
390  const groups = /* @__PURE__ */ new Map();
391  const order = [];
392  for (const v of versions) {
393    const label = formatDayLabel(v.createdAt);
394    if (!groups.has(label)) {
395      groups.set(label, []);
396      order.push(label);
397    }
398    groups.get(label).push(v);
399  }
400  return order.map((label) => ({
401    label,
402    versions: groups.get(label)
403  }));
404}
405function formatDayLabel(iso) {
406  const now = /* @__PURE__ */ new Date();
407  const date = new Date(iso);
408  const nowDay = new Date(now.getFullYear(), now.getMonth(), now.getDate());
409  const thenDay = new Date(
410    date.getFullYear(),
411    date.getMonth(),
412    date.getDate()
413  );
414  const days = Math.round(
415    (nowDay.getTime() - thenDay.getTime()) / (1e3 * 60 * 60 * 24)
416  );
417  if (days === 0) return "Today";
418  if (days === 1) return "Yesterday";
419  if (days < 7) return `${days} days ago`;
420  return date.toLocaleDateString("en-US", {
421    month: "short",
422    day: "numeric"
423  });
424}
425function formatRelativeTime(iso) {
426  const now = Date.now();
427  const then = new Date(iso).getTime();
428  const diff = now - then;
429  const seconds = Math.floor(diff / 1e3);
430  const minutes = Math.floor(seconds / 60);
431  const hours = Math.floor(minutes / 60);
432  const days = Math.floor(hours / 24);
433  if (days > 30) return new Date(iso).toLocaleDateString();
434  if (days > 0) return `${days}d ago`;
435  if (hours > 0) return `${hours}h ago`;
436  if (minutes > 0) return `${minutes}m ago`;
437  return "just now";
438}
439
440// src/welcome-modal.ts
441var import_obsidian5 = require("obsidian");
442var WelcomeModal = class extends import_obsidian5.Modal {
443  constructor(app) {
444    super(app);
445  }
446  onOpen() {
447    const { contentEl } = this;
448    contentEl.addClass("sbl-welcome-modal");
449    contentEl.createEl("h2", { text: "Welcome to sublimated" });
450    contentEl.createEl("p", {
451      text: "sublimated syncs your files with version history, collaboration, and a web viewer \u2014 all powered by git under the hood."
452    });
453    const steps = contentEl.createEl("div", { cls: "sbl-welcome-steps" });
454    const step1 = steps.createDiv({ cls: "sbl-welcome-step" });
455    step1.createEl("strong", { text: "1. Open a sublimated folder as a vault" });
456    step1.createEl("p", {
457      text: "In Finder, open any sublimated folder (or subfolder) under CloudStorage as an Obsidian vault. The plugin activates automatically on synced files."
458    });
459    const step2 = steps.createDiv({ cls: "sbl-welcome-step" });
460    step2.createEl("strong", { text: "2. Status bar shows sync info" });
461    step2.createEl("p", {
462      text: "The bottom bar shows version number, sync status, and author for the current file \u2014 all read from local file metadata, no account needed."
463    });
464    const step3 = steps.createDiv({ cls: "sbl-welcome-step" });
465    step3.createEl("strong", { text: "3. Add an API token for version history" });
466    step3.createEl("p", {
467      text: "To browse past versions, add your API token in Settings \u2192 sublimated. Generate one at sublimated.com/settings/tokens."
468    });
469    const links = contentEl.createDiv({ cls: "sbl-welcome-links" });
470    links.createEl("a", {
471      text: "Documentation",
472      href: "https://sublimated.com/docs/obsidian"
473    });
474    links.createEl("br");
475    links.createEl("a", {
476      text: "Source code",
477      href: "https://sublimated.com/sublimated/code/obsidian"
478    });
479    const footer = contentEl.createDiv({ cls: "sbl-welcome-footer" });
480    footer.createEl("button", {
481      text: "Get started",
482      cls: "mod-cta"
483    }).addEventListener("click", () => this.close());
484  }
485  onClose() {
486    this.contentEl.empty();
487  }
488};
489
490// src/main.ts
491var SublimatedPlugin = class extends import_obsidian6.Plugin {
492  settings = DEFAULT_SETTINGS;
493  lastMetadata = null;
494  statusBarEl = null;
495  async onload() {
496    await this.loadSettings();
497    this.statusBarEl = this.addStatusBarItem();
498    this.statusBarEl.addClass("sbl-status-bar");
499    this.statusBarEl.addEventListener(
500      "click",
501      () => this.openCurrentFileOnWeb()
502    );
503    this.updateStatusBar(null);
504    this.registerView(
505      VERSION_VIEW_TYPE,
506      (leaf) => new VersionView(leaf, this)
507    );
508    this.addCommand({
509      id: "open-on-web",
510      name: "Open on sublimated.com",
511      callback: () => this.openCurrentFileOnWeb()
512    });
513    this.addCommand({
514      id: "show-versions",
515      name: "Show versions",
516      callback: () => this.activateVersionView()
517    });
518    this.addCommand({
519      id: "copy-web-link",
520      name: "Copy web link",
521      callback: () => this.copyWebLink()
522    });
523    this.addRibbonIcon("history", "sublimated versions", () => {
524      this.activateVersionView();
525    });
526    this.registerObsidianProtocolHandler(
527      "sublimated",
528      (params) => this.handleUri(params)
529    );
530    this.addSettingTab(new SublimatedSettingTab(this.app, this));
531    this.registerEvent(
532      this.app.workspace.on("active-leaf-change", () => {
533        this.refreshMetadata();
534      })
535    );
536    this.refreshMetadata();
537    if (!this.settings.hasSeenWelcome) {
538      new WelcomeModal(this.app).open();
539      this.settings.hasSeenWelcome = true;
540      await this.saveSettings();
541    }
542  }
543  onunload() {
544    this.app.workspace.detachLeavesOfType(VERSION_VIEW_TYPE);
545  }
546  async loadSettings() {
547    this.settings = Object.assign(
548      {},
549      DEFAULT_SETTINGS,
550      await this.loadData()
551    );
552  }
553  async saveSettings() {
554    await this.saveData(this.settings);
555  }
556  // detect workspace from xattrs on the currently active file.
557  // every synced file carries com.sublimated.space#PS, so any file
558  // with sublimated metadata identifies the workspace.
559  detectWorkspace() {
560    if (!this.lastMetadata) return null;
561    if (!this.lastMetadata.space && !this.lastMetadata.id) return null;
562    return {
563      space: this.lastMetadata.space ?? null
564    };
565  }
566  async refreshMetadata() {
567    const file = this.app.workspace.getActiveFile();
568    if (!file) {
569      this.lastMetadata = null;
570      this.updateStatusBar(null);
571      return;
572    }
573    if (!isMacOS()) {
574      this.lastMetadata = null;
575      this.updateStatusBar(null);
576      return;
577    }
578    const adapter = this.app.vault.adapter;
579    const basePath = adapter.getBasePath?.();
580    if (!basePath) {
581      this.lastMetadata = null;
582      this.updateStatusBar(null);
583      return;
584    }
585    const absPath = `${basePath}/${file.path}`;
586    this.lastMetadata = await readFileMetadata(absPath);
587    this.updateStatusBar(this.lastMetadata);
588  }
589  updateStatusBar(meta) {
590    if (!this.statusBarEl) return;
591    if (!meta || !meta.space && !meta.id) {
592      this.statusBarEl.setText("");
593      return;
594    }
595    const parts = [];
596    if (meta.syncStatus) {
597      const icon = syncStatusIcon(meta.syncStatus);
598      parts.push(icon ? `${icon} ${meta.syncStatus}` : meta.syncStatus);
599    }
600    if (meta.version) {
601      parts.push(`v${meta.version}`);
602    }
603    if (meta.modifiedBy) {
604      const prefix = meta.modifiedByType === "ai_agent" ? "by AI:" : "by";
605      parts.push(`${prefix} ${meta.modifiedBy}`);
606    }
607    if (meta.branch && meta.branch !== "main") {
608      parts.push(meta.branch);
609    }
610    if (meta.visibility) {
611      parts.push(visibilityIcon(meta.visibility));
612    }
613    this.statusBarEl.setText(parts.join(" "));
614    if (meta.url) {
615      this.statusBarEl.addClass("sbl-clickable");
616    } else {
617      this.statusBarEl.removeClass("sbl-clickable");
618    }
619  }
620  openCurrentFileOnWeb() {
621    const url = this.lastMetadata?.url;
622    if (!url) {
623      new import_obsidian6.Notice("No sublimated URL for this file");
624      return;
625    }
626    window.open(`https://${url}`);
627  }
628  async copyWebLink() {
629    const url = this.lastMetadata?.url;
630    if (!url) {
631      new import_obsidian6.Notice("No sublimated URL for this file");
632      return;
633    }
634    await navigator.clipboard.writeText(`https://${url}`);
635    new import_obsidian6.Notice("Link copied to clipboard");
636  }
637  async activateVersionView() {
638    const existing = this.app.workspace.getLeavesOfType(VERSION_VIEW_TYPE);
639    if (existing.length > 0) {
640      this.app.workspace.revealLeaf(existing[0]);
641      return;
642    }
643    const leaf = this.app.workspace.getRightLeaf(false);
644    if (!leaf) return;
645    await leaf.setViewState({
646      type: VERSION_VIEW_TYPE,
647      active: true
648    });
649    this.app.workspace.revealLeaf(leaf);
650  }
651  handleUri(params) {
652    const { action, file } = params;
653    if (action === "open" && file) {
654      const normalized = (0, import_obsidian6.normalizePath)(file);
655      const existing = this.app.vault.getAbstractFileByPath(normalized);
656      if (existing) {
657        this.app.workspace.openLinkText(normalized, "", false);
658      } else {
659        new import_obsidian6.Notice(`File not found: ${file}`);
660      }
661      return;
662    }
663    if (action === "auth" && params.token) {
664      this.settings.apiToken = params.token;
665      this.saveSettings();
666      new import_obsidian6.Notice("sublimated: signed in successfully");
667      return;
668    }
669    new import_obsidian6.Notice(`Unknown sublimated action: ${action}`);
670  }
671};
672function syncStatusIcon(status) {
673  switch (status) {
674    case "synced":
675      return "\u2713";
676    case "uploading":
677      return "\u2191";
678    case "downloading":
679      return "\u2193";
680    case "error":
681      return "!";
682    case "conflict":
683      return "\u26A0";
684    default:
685      return "";
686  }
687}
688function visibilityIcon(visibility) {
689  switch (visibility) {
690    case "public":
691      return "\u{1F310}";
692    case "shared":
693      return "\u{1F465}";
694    case "private":
695      return "\u{1F512}";
696    default:
697      return "";
698  }
699}
700//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/main.ts", "src/settings.ts", "src/api.ts", "src/xattr.ts", "src/version-view.ts", "src/welcome-modal.ts"],
  "sourcesContent": ["import {\n\tNotice,\n\tPlugin,\n\tWorkspaceLeaf,\n\tnormalizePath,\n} from \"obsidian\";\nimport {\n\ttype SublimatedSettings,\n\tDEFAULT_SETTINGS,\n\tSublimatedSettingTab,\n} from \"./settings\";\nimport { type FileMetadata, readFileMetadata, isMacOS } from \"./xattr\";\nimport { VersionView, VERSION_VIEW_TYPE } from \"./version-view\";\nimport { WelcomeModal } from \"./welcome-modal\";\n\nexport default class SublimatedPlugin extends Plugin {\n\tsettings: SublimatedSettings = DEFAULT_SETTINGS;\n\tlastMetadata: FileMetadata | null = null;\n\n\tprivate statusBarEl: HTMLElement | null = null;\n\n\tasync onload(): Promise<void> {\n\t\tawait this.loadSettings();\n\n\t\t// status bar\n\t\tthis.statusBarEl = this.addStatusBarItem();\n\t\tthis.statusBarEl.addClass(\"sbl-status-bar\");\n\t\tthis.statusBarEl.addEventListener(\"click\", () =>\n\t\t\tthis.openCurrentFileOnWeb()\n\t\t);\n\t\tthis.updateStatusBar(null);\n\n\t\t// register version history view\n\t\tthis.registerView(\n\t\t\tVERSION_VIEW_TYPE,\n\t\t\t(leaf) => new VersionView(leaf, this)\n\t\t);\n\n\t\t// commands\n\t\tthis.addCommand({\n\t\t\tid: \"open-on-web\",\n\t\t\tname: \"Open on sublimated.com\",\n\t\t\tcallback: () => this.openCurrentFileOnWeb(),\n\t\t});\n\n\t\tthis.addCommand({\n\t\t\tid: \"show-versions\",\n\t\t\tname: \"Show versions\",\n\t\t\tcallback: () => this.activateVersionView(),\n\t\t});\n\n\t\tthis.addCommand({\n\t\t\tid: \"copy-web-link\",\n\t\t\tname: \"Copy web link\",\n\t\t\tcallback: () => this.copyWebLink(),\n\t\t});\n\n\t\t// ribbon icon for version sidebar\n\t\tthis.addRibbonIcon(\"history\", \"sublimated versions\", () => {\n\t\t\tthis.activateVersionView();\n\t\t});\n\n\t\t// URI handler: obsidian://sublimated?action=open&file=path/to/note.md\n\t\tthis.registerObsidianProtocolHandler(\n\t\t\t\"sublimated\",\n\t\t\t(params) => this.handleUri(params)\n\t\t);\n\n\t\t// settings tab\n\t\tthis.addSettingTab(new SublimatedSettingTab(this.app, this));\n\n\t\t// update status bar when active file changes\n\t\tthis.registerEvent(\n\t\t\tthis.app.workspace.on(\"active-leaf-change\", () => {\n\t\t\t\tthis.refreshMetadata();\n\t\t\t})\n\t\t);\n\n\t\t// initial metadata read\n\t\tthis.refreshMetadata();\n\n\t\t// welcome modal on first install\n\t\tif (!this.settings.hasSeenWelcome) {\n\t\t\tnew WelcomeModal(this.app).open();\n\t\t\tthis.settings.hasSeenWelcome = true;\n\t\t\tawait this.saveSettings();\n\t\t}\n\t}\n\n\tonunload(): void {\n\t\tthis.app.workspace.detachLeavesOfType(VERSION_VIEW_TYPE);\n\t}\n\n\tasync loadSettings(): Promise<void> {\n\t\tthis.settings = Object.assign(\n\t\t\t{},\n\t\t\tDEFAULT_SETTINGS,\n\t\t\tawait this.loadData()\n\t\t);\n\t}\n\n\tasync saveSettings(): Promise<void> {\n\t\tawait this.saveData(this.settings);\n\t}\n\n\t// detect workspace from xattrs on the currently active file.\n\t// every synced file carries com.sublimated.space#PS, so any file\n\t// with sublimated metadata identifies the workspace.\n\tdetectWorkspace(): { space: string | null } | null {\n\t\tif (!this.lastMetadata) return null;\n\t\tif (!this.lastMetadata.space && !this.lastMetadata.id) return null;\n\t\treturn {\n\t\t\tspace: this.lastMetadata.space ?? null,\n\t\t};\n\t}\n\n\tprivate async refreshMetadata(): Promise<void> {\n\t\tconst file = this.app.workspace.getActiveFile();\n\t\tif (!file) {\n\t\t\tthis.lastMetadata = null;\n\t\t\tthis.updateStatusBar(null);\n\t\t\treturn;\n\t\t}\n\n\t\tif (!isMacOS()) {\n\t\t\tthis.lastMetadata = null;\n\t\t\tthis.updateStatusBar(null);\n\t\t\treturn;\n\t\t}\n\n\t\t// get absolute path via vault adapter\n\t\tconst adapter = this.app.vault.adapter;\n\t\tconst basePath = (adapter as { getBasePath?: () => string })\n\t\t\t.getBasePath?.();\n\t\tif (!basePath) {\n\t\t\tthis.lastMetadata = null;\n\t\t\tthis.updateStatusBar(null);\n\t\t\treturn;\n\t\t}\n\n\t\tconst absPath = `${basePath}/${file.path}`;\n\t\tthis.lastMetadata = await readFileMetadata(absPath);\n\t\tthis.updateStatusBar(this.lastMetadata);\n\t}\n\n\tprivate updateStatusBar(meta: FileMetadata | null): void {\n\t\tif (!this.statusBarEl) return;\n\n\t\t// no sublimated xattrs \u2192 file isn't tracked by sublimated, hide status bar\n\t\tif (!meta || (!meta.space && !meta.id)) {\n\t\t\tthis.statusBarEl.setText(\"\");\n\t\t\treturn;\n\t\t}\n\n\t\t// compact format: \"\u2713 synced v21 by anton\" (sync + version + author + optional branch/visibility)\n\t\tconst parts: string[] = [];\n\n\t\tif (meta.syncStatus) {\n\t\t\tconst icon = syncStatusIcon(meta.syncStatus);\n\t\t\tparts.push(icon ? `${icon} ${meta.syncStatus}` : meta.syncStatus);\n\t\t}\n\n\t\tif (meta.version) {\n\t\t\tparts.push(`v${meta.version}`);\n\t\t}\n\n\t\tif (meta.modifiedBy) {\n\t\t\tconst prefix =\n\t\t\t\tmeta.modifiedByType === \"ai_agent\" ? \"by AI:\" : \"by\";\n\t\t\tparts.push(`${prefix} ${meta.modifiedBy}`);\n\t\t}\n\n\t\tif (meta.branch && meta.branch !== \"main\") {\n\t\t\tparts.push(meta.branch);\n\t\t}\n\n\t\tif (meta.visibility) {\n\t\t\tparts.push(visibilityIcon(meta.visibility));\n\t\t}\n\n\t\tthis.statusBarEl.setText(parts.join(\" \"));\n\n\t\t// show pointer cursor when URL available\n\t\tif (meta.url) {\n\t\t\tthis.statusBarEl.addClass(\"sbl-clickable\");\n\t\t} else {\n\t\t\tthis.statusBarEl.removeClass(\"sbl-clickable\");\n\t\t}\n\t}\n\n\tprivate openCurrentFileOnWeb(): void {\n\t\tconst url = this.lastMetadata?.url;\n\t\tif (!url) {\n\t\t\tnew Notice(\"No sublimated URL for this file\");\n\t\t\treturn;\n\t\t}\n\t\twindow.open(`https://${url}`);\n\t}\n\n\tprivate async copyWebLink(): Promise<void> {\n\t\tconst url = this.lastMetadata?.url;\n\t\tif (!url) {\n\t\t\tnew Notice(\"No sublimated URL for this file\");\n\t\t\treturn;\n\t\t}\n\t\tawait navigator.clipboard.writeText(`https://${url}`);\n\t\tnew Notice(\"Link copied to clipboard\");\n\t}\n\n\tprivate async activateVersionView(): Promise<void> {\n\t\tconst existing =\n\t\t\tthis.app.workspace.getLeavesOfType(VERSION_VIEW_TYPE);\n\t\tif (existing.length > 0) {\n\t\t\tthis.app.workspace.revealLeaf(existing[0]);\n\t\t\treturn;\n\t\t}\n\n\t\tconst leaf = this.app.workspace.getRightLeaf(false);\n\t\tif (!leaf) return;\n\t\tawait leaf.setViewState({\n\t\t\ttype: VERSION_VIEW_TYPE,\n\t\t\tactive: true,\n\t\t});\n\t\tthis.app.workspace.revealLeaf(leaf);\n\t}\n\n\tprivate handleUri(params: Record<string, string>): void {\n\t\tconst { action, file } = params;\n\n\t\tif (action === \"open\" && file) {\n\t\t\tconst normalized = normalizePath(file);\n\t\t\tconst existing = this.app.vault.getAbstractFileByPath(normalized);\n\t\t\tif (existing) {\n\t\t\t\tthis.app.workspace.openLinkText(normalized, \"\", false);\n\t\t\t} else {\n\t\t\t\tnew Notice(`File not found: ${file}`);\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\n\t\tif (action === \"auth\" && params.token) {\n\t\t\t// future: OAuth flow stores token from redirect\n\t\t\tthis.settings.apiToken = params.token;\n\t\t\tthis.saveSettings();\n\t\t\tnew Notice(\"sublimated: signed in successfully\");\n\t\t\treturn;\n\t\t}\n\n\t\tnew Notice(`Unknown sublimated action: ${action}`);\n\t}\n}\n\nfunction syncStatusIcon(status: string): string {\n\tswitch (status) {\n\t\tcase \"synced\":\n\t\t\treturn \"\u2713\";\n\t\tcase \"uploading\":\n\t\t\treturn \"\u2191\";\n\t\tcase \"downloading\":\n\t\t\treturn \"\u2193\";\n\t\tcase \"error\":\n\t\t\treturn \"!\";\n\t\tcase \"conflict\":\n\t\t\treturn \"\u26A0\";\n\t\tdefault:\n\t\t\treturn \"\";\n\t}\n}\n\nfunction visibilityIcon(visibility: string): string {\n\tswitch (visibility) {\n\t\tcase \"public\":\n\t\t\treturn \"\uD83C\uDF10\";\n\t\tcase \"shared\":\n\t\t\treturn \"\uD83D\uDC65\";\n\t\tcase \"private\":\n\t\t\treturn \"\uD83D\uDD12\";\n\t\tdefault:\n\t\t\treturn \"\";\n\t}\n}\n", "import { App, Notice, PluginSettingTab, Setting } from \"obsidian\";\nimport type SublimatedPlugin from \"./main\";\nimport { SublimatedApi } from \"./api\";\n\nexport interface SublimatedSettings {\n\tapiToken: string;\n\thasSeenWelcome: boolean;\n}\n\nexport const DEFAULT_SETTINGS: SublimatedSettings = {\n\tapiToken: \"\",\n\thasSeenWelcome: false,\n};\n\nexport class SublimatedSettingTab extends PluginSettingTab {\n\tplugin: SublimatedPlugin;\n\n\tconstructor(app: App, plugin: SublimatedPlugin) {\n\t\tsuper(app, plugin);\n\t\tthis.plugin = plugin;\n\t}\n\n\tdisplay(): void {\n\t\tconst { containerEl } = this;\n\t\tcontainerEl.empty();\n\n\t\t// branding\n\t\tconst header = containerEl.createDiv({ cls: \"sbl-settings-header\" });\n\t\theader.createEl(\"h2\", { text: \"sublimated\" });\n\t\theader.createEl(\"p\", {\n\t\t\ttext: \"Sync status, version history, and deep links.\",\n\t\t\tcls: \"setting-item-description\",\n\t\t});\n\n\t\t// workspace detection (based on xattrs of the last opened file)\n\t\tconst workspaceInfo = this.plugin.detectWorkspace();\n\t\tif (workspaceInfo) {\n\t\t\tnew Setting(containerEl)\n\t\t\t\t.setName(\"Detected workspace\")\n\t\t\t\t.setDesc(\n\t\t\t\t\t`Space: ${workspaceInfo.space || \"unknown\"}`\n\t\t\t\t);\n\t\t} else {\n\t\t\tnew Setting(containerEl)\n\t\t\t\t.setName(\"No sublimated file open\")\n\t\t\t\t.setDesc(\n\t\t\t\t\t\"Open any synced file from a sublimated folder to see workspace info.\"\n\t\t\t\t);\n\t\t}\n\n\t\t// API token\n\t\tnew Setting(containerEl)\n\t\t\t.setName(\"API token\")\n\t\t\t.setDesc(\n\t\t\t\t\"Required for version history. Generate at sublimated.com/settings/tokens\"\n\t\t\t)\n\t\t\t.addText((text) =>\n\t\t\t\ttext\n\t\t\t\t\t.setPlaceholder(\"sk_...\")\n\t\t\t\t\t.setValue(this.plugin.settings.apiToken)\n\t\t\t\t\t.onChange(async (value) => {\n\t\t\t\t\t\tthis.plugin.settings.apiToken = value;\n\t\t\t\t\t\tawait this.plugin.saveSettings();\n\t\t\t\t\t})\n\t\t\t);\n\n\t\t// test connection\n\t\tnew Setting(containerEl)\n\t\t\t.setName(\"Test connection\")\n\t\t\t.setDesc(\"Verify your API token works\")\n\t\t\t.addButton((btn) =>\n\t\t\t\tbtn.setButtonText(\"Test\").onClick(async () => {\n\t\t\t\t\tif (!this.plugin.settings.apiToken) {\n\t\t\t\t\t\tnew Notice(\"No API token configured\");\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tbtn.setButtonText(\"Testing...\");\n\t\t\t\t\tbtn.setDisabled(true);\n\t\t\t\t\tconst api = new SublimatedApi(\n\t\t\t\t\t\tthis.plugin.settings.apiToken\n\t\t\t\t\t);\n\t\t\t\t\tconst result = await api.testConnection();\n\t\t\t\t\tif (result.ok) {\n\t\t\t\t\t\tnew Notice(\n\t\t\t\t\t\t\t`Connected as ${result.username}`\n\t\t\t\t\t\t);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tnew Notice(\n\t\t\t\t\t\t\t`Connection failed: ${result.error}`\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t\tbtn.setButtonText(\"Test\");\n\t\t\t\t\tbtn.setDisabled(false);\n\t\t\t\t})\n\t\t\t);\n\n\t\t// links\n\t\tcontainerEl.createEl(\"div\", { cls: \"sbl-settings-links\" }, (el) => {\n\t\t\tel.createEl(\"a\", {\n\t\t\t\ttext: \"sublimated.com\",\n\t\t\t\thref: \"https://sublimated.com\",\n\t\t\t});\n\t\t\tel.createEl(\"span\", { text: \" \u00B7 \" });\n\t\t\tel.createEl(\"a\", {\n\t\t\t\ttext: \"Documentation\",\n\t\t\t\thref: \"https://sublimated.com/docs/obsidian\",\n\t\t\t});\n\t\t\tel.createEl(\"span\", { text: \" \u00B7 \" });\n\t\t\tel.createEl(\"a\", {\n\t\t\t\ttext: \"Source code\",\n\t\t\t\thref: \"https://sublimated.com/sublimated/code/obsidian\",\n\t\t\t});\n\t\t});\n\t}\n}\n", "import { requestUrl } from \"obsidian\";\n\nconst API_BASE = \"https://api.sublimated.com\";\n\nexport interface Version {\n\tid: string;\n\tnumber: number;\n\tauthorName: string;\n\tauthorType: string;\n\tmessage: string | null;\n\tcreatedAt: string;\n}\n\nexport class AuthRequiredError extends Error {\n\tconstructor(public status: number) {\n\t\tsuper(`auth required (${status})`);\n\t\tthis.name = \"AuthRequiredError\";\n\t}\n}\n\n// Raw wire format from api.sublimated.com\ninterface RawActor {\n\tusername: string | null;\n\tname: string | null;\n\trole: string;\n\tactor_type: string;\n}\n\ninterface RawVersion {\n\tid: string;\n\titem_id: string;\n\tversion: number;\n\tcontent_hash: string;\n\tblob_sha1: string | null;\n\tsize_bytes: number;\n\tmessage: string | null;\n\tname: string | null;\n\tcreated_at: string;\n\tactors: RawActor[];\n}\n\ninterface ApiEnvelope<T> {\n\tok: boolean;\n\tdata?: T;\n\terror?: { type: string; message?: string };\n}\n\nexport interface TestConnectionResult {\n\tok: boolean;\n\tusername?: string;\n\terror?: string;\n}\n\nexport class SublimatedApi {\n\tconstructor(private token: string) {}\n\n\tprivate async request<T>(path: string): Promise<T> {\n\t\tconst headers: Record<string, string> = {\n\t\t\tAccept: \"application/json\",\n\t\t};\n\t\tif (this.token) {\n\t\t\theaders.Authorization = `Bearer ${this.token}`;\n\t\t}\n\t\tconst response = await requestUrl({\n\t\t\turl: `${API_BASE}${path}`,\n\t\t\theaders,\n\t\t\tthrow: false,\n\t\t});\n\n\t\tif (response.status === 401 || response.status === 403) {\n\t\t\tthrow new AuthRequiredError(response.status);\n\t\t}\n\t\tif (response.status >= 400) {\n\t\t\tthrow new Error(\n\t\t\t\t`API error ${response.status}: ${response.text}`\n\t\t\t);\n\t\t}\n\n\t\tconst body = response.json as ApiEnvelope<T>;\n\t\tif (!body.ok || body.data === undefined) {\n\t\t\tconst msg = body.error?.message || body.error?.type || \"unknown error\";\n\t\t\tthrow new Error(`API error: ${msg}`);\n\t\t}\n\t\treturn body.data;\n\t}\n\n\tasync getVersions(\n\t\tspaceSlug: string,\n\t\titemId: string\n\t): Promise<Version[]> {\n\t\tconst raw = await this.request<RawVersion[]>(\n\t\t\t`/v1/spaces/${encodeURIComponent(spaceSlug)}/items/${encodeURIComponent(itemId)}/versions`\n\t\t);\n\t\treturn raw.map(mapVersion).reverse();\n\t}\n\n\tasync testConnection(): Promise<TestConnectionResult> {\n\t\ttry {\n\t\t\tconst data = await this.request<{ username: string }>(\n\t\t\t\t\"/v1/me\"\n\t\t\t);\n\t\t\treturn { ok: true, username: data.username };\n\t\t} catch (e) {\n\t\t\treturn {\n\t\t\t\tok: false,\n\t\t\t\terror: e instanceof Error ? e.message : \"Unknown error\",\n\t\t\t};\n\t\t}\n\t}\n}\n\nfunction mapVersion(r: RawVersion): Version {\n\t// pick the author actor; fall back to the first actor or a placeholder\n\tconst author =\n\t\tr.actors.find((a) => a.role === \"author\") ?? r.actors[0] ?? null;\n\treturn {\n\t\tid: r.id,\n\t\tnumber: r.version,\n\t\tauthorName: author?.name ?? author?.username ?? \"unknown\",\n\t\tauthorType: author?.actor_type ?? \"person\",\n\t\tmessage: r.message,\n\t\tcreatedAt: r.created_at,\n\t};\n}\n", "import { exec } from \"child_process\";\nimport { Platform } from \"obsidian\";\n\nconst XATTR_PREFIX = \"com.sublimated.\";\nconst XATTR_SUFFIX = \"#PS\";\n\nexport interface FileMetadata {\n\tversion: string | null;\n\tcommit: string | null;\n\turl: string | null;\n\tcontentHash: string | null;\n\tid: string | null;\n\tcreatedBy: string | null;\n\tmodifiedBy: string | null;\n\tmodifiedByType: string | null;\n\tsyncStatus: string | null;\n\tspace: string | null;\n\tbranch: string | null;\n\tmodifiedAt: string | null;\n\tvisibility: string | null;\n}\n\nconst ATTRS: (keyof FileMetadata)[] = [\n\t\"version\",\n\t\"commit\",\n\t\"url\",\n\t\"contentHash\",\n\t\"id\",\n\t\"createdBy\",\n\t\"modifiedBy\",\n\t\"modifiedByType\",\n\t\"syncStatus\",\n\t\"space\",\n\t\"branch\",\n\t\"modifiedAt\",\n\t\"visibility\",\n];\n\nfunction attrToXattrName(attr: string): string {\n\t// camelCase \u2192 kebab-case: contentHash \u2192 content-hash\n\tconst kebab = attr.replace(/[A-Z]/g, (c) => \"-\" + c.toLowerCase());\n\treturn `${XATTR_PREFIX}${kebab}${XATTR_SUFFIX}`;\n}\n\nfunction readXattr(path: string, xattrName: string): Promise<string | null> {\n\treturn new Promise((resolve) => {\n\t\texec(\n\t\t\t`xattr -p ${JSON.stringify(xattrName)} ${JSON.stringify(path)}`,\n\t\t\t{ timeout: 2000 },\n\t\t\t(err, stdout) => {\n\t\t\t\tif (err) {\n\t\t\t\t\tresolve(null);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tresolve(stdout.trim() || null);\n\t\t\t}\n\t\t);\n\t});\n}\n\nexport async function readFileMetadata(\n\tpath: string\n): Promise<FileMetadata | null> {\n\tif (!Platform.isMacOS) return null;\n\n\tconst results = await Promise.all(\n\t\tATTRS.map((attr) => readXattr(path, attrToXattrName(attr)))\n\t);\n\n\t// If no xattrs found at all, this isn't a sublimated file\n\tif (results.every((r) => r === null)) return null;\n\n\tconst meta: FileMetadata = {\n\t\tversion: null, commit: null, url: null, contentHash: null,\n\t\tid: null, createdBy: null, modifiedBy: null, modifiedByType: null,\n\t\tsyncStatus: null, space: null, branch: null, modifiedAt: null, visibility: null,\n\t};\n\tATTRS.forEach((attr, i) => {\n\t\tmeta[attr] = results[i];\n\t});\n\treturn meta;\n}\n\nexport function isMacOS(): boolean {\n\treturn Platform.isMacOS;\n}\n", "import { ItemView, Notice, WorkspaceLeaf } from \"obsidian\";\nimport type SublimatedPlugin from \"./main\";\nimport { SublimatedApi, AuthRequiredError, type Version } from \"./api\";\n\nexport const VERSION_VIEW_TYPE = \"sublimated-versions\";\n\nexport class VersionView extends ItemView {\n\tplugin: SublimatedPlugin;\n\n\tconstructor(leaf: WorkspaceLeaf, plugin: SublimatedPlugin) {\n\t\tsuper(leaf);\n\t\tthis.plugin = plugin;\n\t}\n\n\tgetViewType(): string {\n\t\treturn VERSION_VIEW_TYPE;\n\t}\n\n\tgetDisplayText(): string {\n\t\treturn \"sublimated versions\";\n\t}\n\n\tgetIcon(): string {\n\t\treturn \"history\";\n\t}\n\n\tasync onOpen(): Promise<void> {\n\t\tawait this.refresh();\n\t\t// refresh when active file changes\n\t\tthis.registerEvent(\n\t\t\tthis.app.workspace.on(\"active-leaf-change\", () => {\n\t\t\t\tthis.refresh();\n\t\t\t})\n\t\t);\n\t}\n\n\tasync refresh(): Promise<void> {\n\t\tconst { contentEl } = this;\n\t\tcontentEl.empty();\n\t\tcontentEl.addClass(\"sbl-version-view\");\n\n\t\tconst activeFile = this.app.workspace.getActiveFile();\n\t\tif (!activeFile) {\n\t\t\tcontentEl.createEl(\"p\", {\n\t\t\t\ttext: \"No file open.\",\n\t\t\t\tcls: \"sbl-version-empty\",\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\t// read xattrs to get space + item ID\n\t\tconst meta = this.plugin.lastMetadata;\n\t\tif (!meta?.space || !meta?.id) {\n\t\t\tcontentEl.createEl(\"p\", {\n\t\t\t\ttext: \"Not a sublimated file.\",\n\t\t\t\tcls: \"sbl-version-empty\",\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\tcontentEl.createEl(\"h4\", {\n\t\t\ttext: activeFile.name,\n\t\t\tcls: \"sbl-version-filename\",\n\t\t});\n\n\t\tconst loading = contentEl.createEl(\"p\", {\n\t\t\ttext: \"Loading versions...\",\n\t\t\tcls: \"sbl-version-loading\",\n\t\t});\n\n\t\ttry {\n\t\t\tconst api = new SublimatedApi(this.plugin.settings.apiToken);\n\t\t\tconst versions = await api.getVersions(meta.space, meta.id);\n\t\t\tloading.remove();\n\n\t\t\tif (versions.length === 0) {\n\t\t\t\tcontentEl.createEl(\"p\", {\n\t\t\t\t\ttext: \"No versions found.\",\n\t\t\t\t\tcls: \"sbl-version-empty\",\n\t\t\t\t});\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst list = contentEl.createEl(\"div\", {\n\t\t\t\tcls: \"sbl-version-list\",\n\t\t\t});\n\t\t\tconst groups = groupByDay(versions);\n\t\t\tfor (const group of groups) {\n\t\t\t\tlist.createEl(\"div\", {\n\t\t\t\t\ttext: group.label,\n\t\t\t\t\tcls: \"sbl-version-day\",\n\t\t\t\t});\n\t\t\t\tfor (const v of group.versions) {\n\t\t\t\t\tthis.renderVersion(list, v, meta.url);\n\t\t\t\t}\n\t\t\t}\n\t\t} catch (e) {\n\t\t\tloading.remove();\n\t\t\tif (e instanceof AuthRequiredError) {\n\t\t\t\tcontentEl.createEl(\"p\", {\n\t\t\t\t\ttext: \"This file is private \u2014 add an API token to view version history.\",\n\t\t\t\t\tcls: \"sbl-version-empty\",\n\t\t\t\t});\n\t\t\t\tcontentEl.createEl(\"p\", {\n\t\t\t\t\ttext: \"Configure in Settings \u2192 sublimated\",\n\t\t\t\t\tcls: \"sbl-version-hint\",\n\t\t\t\t});\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tcontentEl.createEl(\"p\", {\n\t\t\t\ttext: `Error: ${e instanceof Error ? e.message : \"Unknown\"}`,\n\t\t\t\tcls: \"sbl-version-error\",\n\t\t\t});\n\t\t}\n\t}\n\n\tprivate renderVersion(\n\t\tcontainer: HTMLElement,\n\t\tv: Version,\n\t\tfileUrl: string | null\n\t): void {\n\t\tconst item = container.createDiv({ cls: \"sbl-version-item\" });\n\n\t\tconst header = item.createDiv({ cls: \"sbl-version-header\" });\n\t\theader.createEl(\"span\", {\n\t\t\ttext: `v${v.number}`,\n\t\t\tcls: \"sbl-version-number\",\n\t\t});\n\t\theader.createEl(\"span\", {\n\t\t\ttext: v.authorName,\n\t\t\tcls: \"sbl-version-author\",\n\t\t});\n\n\t\tconst time = item.createDiv({ cls: \"sbl-version-time\" });\n\t\ttime.createEl(\"span\", {\n\t\t\ttext: formatRelativeTime(v.createdAt),\n\t\t\tattr: { title: new Date(v.createdAt).toLocaleString() },\n\t\t});\n\n\t\tif (v.message) {\n\t\t\titem.createDiv({\n\t\t\t\ttext: v.message,\n\t\t\t\tcls: \"sbl-version-message\",\n\t\t\t});\n\t\t}\n\n\t\tif (fileUrl) {\n\t\t\tconst webUrl = `https://${fileUrl}/~versions/v${v.number}`;\n\t\t\tconst link = item.createEl(\"a\", {\n\t\t\t\ttext: \"view on web\",\n\t\t\t\tcls: \"sbl-version-web-link\",\n\t\t\t\thref: webUrl,\n\t\t\t});\n\t\t\tlink.addEventListener(\"click\", (e) => {\n\t\t\t\te.preventDefault();\n\t\t\t\twindow.open(webUrl);\n\t\t\t});\n\t\t}\n\t}\n\n\tasync onClose(): Promise<void> {\n\t\t// cleanup handled by obsidian\n\t}\n}\n\ninterface DayGroup {\n\tlabel: string;\n\tversions: Version[];\n}\n\nfunction groupByDay(versions: Version[]): DayGroup[] {\n\tconst groups = new Map<string, Version[]>();\n\tconst order: string[] = [];\n\n\tfor (const v of versions) {\n\t\tconst label = formatDayLabel(v.createdAt);\n\t\tif (!groups.has(label)) {\n\t\t\tgroups.set(label, []);\n\t\t\torder.push(label);\n\t\t}\n\t\tgroups.get(label)!.push(v);\n\t}\n\n\treturn order.map((label) => ({\n\t\tlabel,\n\t\tversions: groups.get(label)!,\n\t}));\n}\n\nfunction formatDayLabel(iso: string): string {\n\tconst now = new Date();\n\tconst date = new Date(iso);\n\n\tconst nowDay = new Date(now.getFullYear(), now.getMonth(), now.getDate());\n\tconst thenDay = new Date(\n\t\tdate.getFullYear(),\n\t\tdate.getMonth(),\n\t\tdate.getDate()\n\t);\n\tconst days = Math.round(\n\t\t(nowDay.getTime() - thenDay.getTime()) / (1000 * 60 * 60 * 24)\n\t);\n\n\tif (days === 0) return \"Today\";\n\tif (days === 1) return \"Yesterday\";\n\tif (days < 7) return `${days} days ago`;\n\treturn date.toLocaleDateString(\"en-US\", {\n\t\tmonth: \"short\",\n\t\tday: \"numeric\",\n\t});\n}\n\nfunction formatRelativeTime(iso: string): string {\n\tconst now = Date.now();\n\tconst then = new Date(iso).getTime();\n\tconst diff = now - then;\n\tconst seconds = Math.floor(diff / 1000);\n\tconst minutes = Math.floor(seconds / 60);\n\tconst hours = Math.floor(minutes / 60);\n\tconst days = Math.floor(hours / 24);\n\n\tif (days > 30) return new Date(iso).toLocaleDateString();\n\tif (days > 0) return `${days}d ago`;\n\tif (hours > 0) return `${hours}h ago`;\n\tif (minutes > 0) return `${minutes}m ago`;\n\treturn \"just now\";\n}\n", "import { App, Modal } from \"obsidian\";\n\nexport class WelcomeModal extends Modal {\n\tconstructor(app: App) {\n\t\tsuper(app);\n\t}\n\n\tonOpen(): void {\n\t\tconst { contentEl } = this;\n\t\tcontentEl.addClass(\"sbl-welcome-modal\");\n\n\t\tcontentEl.createEl(\"h2\", { text: \"Welcome to sublimated\" });\n\n\t\tcontentEl.createEl(\"p\", {\n\t\t\ttext: \"sublimated syncs your files with version history, collaboration, and a web viewer \u2014 all powered by git under the hood.\",\n\t\t});\n\n\t\tconst steps = contentEl.createEl(\"div\", { cls: \"sbl-welcome-steps\" });\n\n\t\tconst step1 = steps.createDiv({ cls: \"sbl-welcome-step\" });\n\t\tstep1.createEl(\"strong\", { text: \"1. Open a sublimated folder as a vault\" });\n\t\tstep1.createEl(\"p\", {\n\t\t\ttext: \"In Finder, open any sublimated folder (or subfolder) under CloudStorage as an Obsidian vault. The plugin activates automatically on synced files.\",\n\t\t});\n\n\t\tconst step2 = steps.createDiv({ cls: \"sbl-welcome-step\" });\n\t\tstep2.createEl(\"strong\", { text: \"2. Status bar shows sync info\" });\n\t\tstep2.createEl(\"p\", {\n\t\t\ttext: \"The bottom bar shows version number, sync status, and author for the current file \u2014 all read from local file metadata, no account needed.\",\n\t\t});\n\n\t\tconst step3 = steps.createDiv({ cls: \"sbl-welcome-step\" });\n\t\tstep3.createEl(\"strong\", { text: \"3. Add an API token for version history\" });\n\t\tstep3.createEl(\"p\", {\n\t\t\ttext: \"To browse past versions, add your API token in Settings \u2192 sublimated. Generate one at sublimated.com/settings/tokens.\",\n\t\t});\n\n\t\tconst links = contentEl.createDiv({ cls: \"sbl-welcome-links\" });\n\t\tlinks.createEl(\"a\", {\n\t\t\ttext: \"Documentation\",\n\t\t\thref: \"https://sublimated.com/docs/obsidian\",\n\t\t});\n\t\tlinks.createEl(\"br\");\n\t\tlinks.createEl(\"a\", {\n\t\t\ttext: \"Source code\",\n\t\t\thref: \"https://sublimated.com/sublimated/code/obsidian\",\n\t\t});\n\n\t\tconst footer = contentEl.createDiv({ cls: \"sbl-welcome-footer\" });\n\t\tfooter.createEl(\"button\", {\n\t\t\ttext: \"Get started\",\n\t\t\tcls: \"mod-cta\",\n\t\t}).addEventListener(\"click\", () => this.close());\n\t}\n\n\tonClose(): void {\n\t\tthis.contentEl.empty();\n\t}\n}\n"],
  "mappings": "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",
  "names": ["import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian", "import_obsidian"]
}


1# obsidian plugin
2
3Obsidian community plugin for sublimated. reads file metadata directly from xattrs set by FileProvider. no signup required for core features.
4
5consistency rule: VS Code plugin (src/vscode-sublimated/) is the reference implementation. both plugins must show the same information in the same format, adapted to each platform's UI.
6
7macOS only for now. iOS later. no Windows/Linux — sublimated itself is macOS/iOS only.
8
9
10## xattrs
11
12FileProvider writes these on every synced file (all implemented and working):
13- `com.sublimated.version#PS` — version number (integer)
14- `com.sublimated.commit#PS` — last commit hash
15- `com.sublimated.url#PS` — web link (sublimated.com/anton/blog/readme_md)
16- `com.sublimated.content-hash#PS` — BLAKE3 hash
17- `com.sublimated.id#PS` — item ID (stable across renames)
18- `com.sublimated.created-by#PS` — original author name
19- `com.sublimated.modified-by#PS` — last author name
20- `com.sublimated.modified-by-type#PS` — person/ai_agent/bot
21- `com.sublimated.sync-status#PS` — synced/uploading/downloading/error
22- `com.sublimated.space#PS` — space slug
23- `com.sublimated.branch#PS` — current branch name
24- `com.sublimated.modified-at#PS` — server-side timestamp of last change
25
26plugin reads these directly from filesystem. no API calls, no token, no signup for core features.
27
28## official Obsidian APIs only
29
30this plugin only uses official, stable Obsidian APIs:
31- `addStatusBarItem()` — status bar text at the bottom
32- `addRibbonIcon()` — ribbon icon in the left sidebar
33- `registerView()` — custom sidebar panel (version history)
34- `addCommand()` — command palette entries
35- `registerObsidianProtocolHandler()` — URI handler
36- `addSettingTab()` — settings page
37
38Obsidian has no official API for file explorer badges, editor hover tooltips, or inline decorations. VS Code has `FileDecorationProvider`, `HoverProvider`, `CodeLens` etc — Obsidian doesn't. plugins that add file tree badges do it via DOM manipulation (finding internal `fileItems`, appending `<span>` elements, watching with MutationObserver). this is fragile — Obsidian can change its internal DOM structure in any update and badges break silently. not worth the maintenance cost.
39
40we deliberately skip these VS Code features that have no stable Obsidian equivalent:
41- file explorer sync badges (requires DOM hacking)
42- hover tooltips on wikilinks (no HoverProvider API)
43- CodeLens-style section attribution above headings (no CodeLens API)
44- inline editor decorations (no stable decoration API)
45
46## done
47
48- status bar: compact format `✓ synced v21 by anton` (sync icon + version + author + optional branch/visibility). click to open on web. hidden for non-sublimated files. updates on file change
49- version history sidebar: newest-first, grouped by day (Today / Yesterday / N days ago), with author, timestamp, commit message, per-version "view on web" link (`/~versions/v{number}`)
50- anonymous version history: public files fetch history without an API token. private files show a friendly "add token in settings" message on 401/403
51- ribbon icon: history button opens version sidebar
52- view on web: command palette + status bar click opens sublimated.com URL from xattr
53- copy web link: command to copy sublimated.com URL to clipboard
54- open in Obsidian: URI handler (`obsidian://sublimated?action=open&file=path`), OAuth token flow stub (`action=auth`)
55- welcome modal: first-run with setup steps, docs + source links, hasSeenWelcome flag
56- settings page: API token input, test connection, xattr-based workspace detection, links
57- xattr-based workspace detection: per-file, works for subfolder vaults and mixed vaults, no `.sbl/` folder required
58- all 13 xattr fields read: version, commit, url, contentHash, id, createdBy, modifiedBy, modifiedByType, syncStatus, space, branch, modifiedAt, visibility
59
60## todo
61
62### cache layer
63
64Obsidian re-reads all xattrs on every file switch (shells out `xattr` 13 times per tab switch).
65- add TTL-based in-memory cache for xattr reads
66- cache API responses (folder context, file context)
67- invalidate on file save events
68
69### workspace detection
70
71done: per-file xattr-based detection. any file with `com.sublimated.space#PS` identifies the workspace. works for subfolder vaults, works without `.sbl/`, works for mixed vaults.
72
73possible future additions:
74- CloudStorage mount path detection as a fallback for empty vaults: `~/Library/CloudStorage/Sublimated-{space}/` (prod) and `~/Library/CloudStorage/sublimated-dev-{space}/` (dev)
75- cache detected space slug across sessions so settings page shows it before any file is opened
76
77### version history improvements
78
79phase 1 (done):
80- [x] group versions by day: "Today", "Yesterday", "3 days ago", "Mon DD"
81- [x] commit messages render with improved visual layout
82- [x] "view on web" link per version using `/:path/~versions/v{number}` URL pattern
83- [x] newest version first (reverse server order)
84- [x] anonymous fetch for public files (no token needed)
85
86phase 2 (diff viewer, needs API):
87- click version to see content at that point (read-only tab)
88- API: `GET /v1/spaces/:slug/items/:id/diff?v1=X&v2=Y` already exists
89- API: `GET /v1/spaces/:slug/content/:hash` for fetching old version content
90- Obsidian Sync does NOT show diffs natively. community plugin (obsidian-version-history-diff) does but uses private APIs
91- our approach: open old version content in a read-only leaf, let user compare visually. no private APIs
92
93phase 3 (restore):
94- "restore this version" button per version
95- API: `POST /v1/spaces/:slug/items/:id/restore` with `{ from_version: number }` already exists
96
97### OAuth sign-in
98
99add one-click sign-in instead of pasting API tokens:
1001. user clicks "Sign in with sublimated" in settings
1012. browser opens `id.sublimated.com/auth/obsidian`
1023. user signs in, server redirects to `obsidian://sublimated?action=auth&token={token}`
1034. plugin stores token, API calls use `Authorization: Bearer {token}`
104
105plugin-side: `main.ts` already handles the URI. settings.ts needs a "Sign in" button.
106server-side: add GET `/auth/obsidian` route to id.sublimated.com. bearer plugin already set up.
107keep manual API token input as fallback. token should be long-lived.
108
109### comments sidebar
110
111VS Code has full CommentController (513 lines) with gutter "+", threading, resolve, reactions. Obsidian has no comment API — use a sidebar view (official `registerView()` API).
112
113- sidebar view: list comments anchored to specific text
114- author, timestamp, quoted text, resolved/unresolved status
115- threaded replies
116- clicking a comment scrolls to anchored text
117- "resolve" button (API call)
118- new comment creation on sublimated.com (link to web UI)
119- needs new API endpoint — comments are not currently exposed over HTTP
120
121## API endpoints
122
123plugin currently uses:
124- GET /v1/spaces/:slug/items/:id/versions — list version history (anonymous for public items, token required for private)
125
126public items work without an API token. the middleware in `src/shared/auth/authorize.ts` grants anonymous callers `{ read: true }` when folder visibility is public.
127
128## submission
129
130- source of truth: https://sublimated.com/sublimated/code/obsidian
131- GitHub live mirror: https://github.com/sublimates/obsidian — live-synced from sublimated.com
132- todo: PR to obsidianmd/obsidian-releases adding entry to community-plugins.json
133- todo: GitHub release workflow for plugin submission (main.js, manifest.json, styles.css as release assets)
134- todo: README with screenshots, description, setup instructions
135- automated validation + manual review by Obsidian team
136
137## promotion
138
139- r/ObsidianMD
140- Obsidian Forum "Share & showcase"
141- Obsidian Discord #updates
142- twitter #ObsidianMD
143- blog post: "how to use Obsidian with sublimated"