Feedback addressed from Obsidian PR review bot

Author: dustinlyons

src/main.ts

@@ -11,7 +11,7 @@ export default class RiverPlugin extends Plugin {
   syncInterval: number | null = null;
 
   async onload() {
-    console.log("Loading River Sync plugin");
+    console.debug("Loading River Sync plugin");
 
     // Load settings
     await this.loadSettings();
@@ -31,17 +31,17 @@ export default class RiverPlugin extends Plugin {
 
     // Add command for manual sync
     this.addCommand({
-      id: "sync-river-notes",
-      name: "Sync notes from River",
+      id: "sync-notes",
+      name: "Sync notes",
       callback: async () => {
         await this.syncNotes();
       },
     });
 
     // Add command to test connection
     this.addCommand({
-      id: "test-river-connection",
-      name: "Test River connection",
+      id: "test-connection",
+      name: "Test connection",
       callback: async () => {
         await this.testConnection();
       },
@@ -54,7 +54,7 @@ export default class RiverPlugin extends Plugin {
     if (this.settings.syncOnStartup) {
       // Delay startup sync by 2 seconds to let Obsidian fully load
       setTimeout(() => {
-        this.syncNotes();
+        void this.syncNotes();
       }, 2000);
     }
 
@@ -64,8 +64,8 @@ export default class RiverPlugin extends Plugin {
     }
   }
 
-  async onunload() {
-    console.log("Unloading River Sync plugin");
+  onunload() {
+    console.debug("Unloading River Sync plugin");
     this.stopPeriodicSync();
   }
 
@@ -136,18 +136,18 @@ export default class RiverPlugin extends Plugin {
 
   startPeriodicSync() {
     const intervalMs = this.settings.syncInterval * 60 * 1000;
-    console.log(
+    console.debug(
       `River: Starting periodic sync every ${this.settings.syncInterval} minutes`,
     );
 
     this.syncInterval = window.setInterval(() => {
-      this.syncNotes();
+      void this.syncNotes();
     }, intervalMs);
   }
 
   stopPeriodicSync() {
     if (this.syncInterval !== null) {
-      console.log("River: Stopping periodic sync");
+      console.debug("River: Stopping periodic sync");
       window.clearInterval(this.syncInterval);
       this.syncInterval = null;
     }

src/noteCreator.ts

@@ -25,13 +25,13 @@ export class NoteCreator {
     // Check if file already exists
     const existingFile = this.app.vault.getAbstractFileByPath(filepath);
     if (existingFile instanceof TFile) {
-      console.log(`River: File already exists, updating: ${filepath}`);
+      console.debug(`River: File already exists, updating: ${filepath}`);
       await this.app.vault.modify(existingFile, content);
       return existingFile;
     }
 
     // Create new file
-    console.log(`River: Creating note: ${filepath}`);
+    console.debug(`River: Creating note: ${filepath}`);
     const file = await this.app.vault.create(filepath, content);
     return file;
   }
@@ -162,7 +162,7 @@ export class NoteCreator {
 
     const exists = this.app.vault.getAbstractFileByPath(folder);
     if (!exists) {
-      console.log(`River: Creating folder: ${folder}`);
+      console.debug(`River: Creating folder: ${folder}`);
       await this.app.vault.createFolder(folder);
     }
   }

src/riverClient.ts

@@ -1,8 +1,10 @@
+import { requestUrl } from "obsidian";
 import type {
   PendingEmail,
   SyncResponse,
   MarkSyncedResponse,
   ObsidianMetadata,
+  SmsApiResponse,
 } from "./types";
 
 export class RiverClient {
@@ -28,23 +30,23 @@ export class RiverClient {
     }
 
     const url = `${this.apiUrl}/api/staging/${this.userId}/pending`;
-    console.log(`River: Fetching pending emails from ${url}`);
+    console.debug(`River: Fetching pending emails from ${url}`);
 
-    const response = await fetch(url);
+    const response = await requestUrl(url);
 
-    if (!response.ok) {
+    if (response.status >= 400) {
       throw new Error(
-        `Failed to fetch pending emails: ${response.status} ${response.statusText}`,
+        `Failed to fetch pending emails: ${response.status}`,
       );
     }
 
-    const data: SyncResponse = await response.json();
+    const data: SyncResponse = response.json;
 
     if (!data.success) {
       throw new Error("API returned success=false");
     }
 
-    console.log(`River: Found ${data.count} pending emails`);
+    console.debug(`River: Found ${data.count} pending emails`);
 
     // Mark all emails with source
     const emails = data.emails.map((email) => ({
@@ -57,7 +59,7 @@ export class RiverClient {
 
     // Merge and return
     const allMessages = [...emails, ...smsMessages];
-    console.log(
+    console.debug(
       `River: Total pending messages: ${allMessages.length} (${emails.length} emails, ${smsMessages.length} SMS)`,
     );
     return allMessages;
@@ -73,28 +75,28 @@ export class RiverClient {
 
     try {
       const url = `${this.smsApiUrl}/api/sms/staging/pending?userId=${this.userId}`;
-      console.log(`River: Fetching pending SMS from ${url}`);
+      console.debug(`River: Fetching pending SMS from ${url}`);
 
-      const response = await fetch(url);
+      const response = await requestUrl(url);
 
-      if (!response.ok) {
+      if (response.status >= 400) {
         console.warn(
           `River: Failed to fetch SMS (${response.status}), continuing with emails only`,
         );
         return [];
       }
 
-      const data = await response.json();
+      const data = response.json;
 
       if (!data.messages || !Array.isArray(data.messages)) {
         console.warn("River: Invalid SMS response format");
         return [];
       }
 
-      console.log(`River: Found ${data.messages.length} pending SMS`);
+      console.debug(`River: Found ${data.messages.length} pending SMS`);
 
       // Transform SMS messages to PendingEmail format
-      return data.messages.map((sms: any) => {
+      return data.messages.map((sms: SmsApiResponse) => {
         const receivedDate = new Date(sms.received_at);
 
         return {
@@ -132,19 +134,20 @@ export class RiverClient {
     if (source === "sms") {
       // Mark SMS as synced
       const url = `${this.smsApiUrl}/api/sms/staging/${messageId}/synced`;
-      console.log(`River: Marking SMS ${messageId} as synced`);
+      console.debug(`River: Marking SMS ${messageId} as synced`);
 
-      const response = await fetch(url, {
+      const response = await requestUrl({
+        url,
         method: "POST",
         headers: {
           "Content-Type": "application/json",
         },
         body: JSON.stringify({ obsidianMetadata: metadata }),
       });
 
-      if (!response.ok) {
+      if (response.status >= 400) {
         throw new Error(
-          `Failed to mark SMS as synced: ${response.status} ${response.statusText}`,
+          `Failed to mark SMS as synced: ${response.status}`,
         );
       }
 
@@ -153,23 +156,24 @@ export class RiverClient {
 
     // Mark email as synced
     const url = `${this.apiUrl}/api/staging/${messageId}/mark-synced`;
-    console.log(`River: Marking email ${messageId} as synced`);
+    console.debug(`River: Marking email ${messageId} as synced`);
 
-    const response = await fetch(url, {
+    const response = await requestUrl({
+      url,
       method: "POST",
       headers: {
         "Content-Type": "application/json",
       },
       body: JSON.stringify({ obsidianMetadata: metadata }),
     });
 
-    if (!response.ok) {
+    if (response.status >= 400) {
       throw new Error(
-        `Failed to mark email as synced: ${response.status} ${response.statusText}`,
+        `Failed to mark email as synced: ${response.status}`,
       );
     }
 
-    const data: MarkSyncedResponse = await response.json();
+    const data: MarkSyncedResponse = response.json;
 
     if (!data.success) {
       throw new Error("Failed to mark email as synced");
@@ -182,8 +186,8 @@ export class RiverClient {
   async testConnection(): Promise<boolean> {
     try {
       const url = `${this.apiUrl}/health`;
-      const response = await fetch(url);
-      return response.ok;
+      const response = await requestUrl(url);
+      return response.status < 400;
     } catch (error) {
       console.error("River: Connection test failed:", error);
       return false;