fix(remote): stat-first file creation, removes error toast on first use (#51)

On Remote SSH and WSL, Reader.loadEntryForDay, Reader.loadEntryForWeek,
and LoadNotes.loadNote called vscode.workspace.openTextDocument on a
missing file and relied on catching the rejection. VS Code surfaces an
error notification independently of the catch, and the catch itself
filtered errors by prefix-matching the message text — fragile and
inconsistent across the three call sites (the week handler only matched
"cannot open file:", leaving remote weeks broken).

Replace with stat-first via a dedicated fileExists(uri) helper that
wraps vscode.workspace.fs.stat and converts FileSystemError.FileNotFound
to false. Anything else (permission denied, transport unavailable)
propagates so VS Code can surface its own dialog.

While each method is rewritten, drop the new Promise((resolve, reject)
=> ...) wrapper and use native async/await. Scope limited to the three
touched methods; PLAN.md Phase 2.2 still owns the rest.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: pajoma

src/actions/reader.ts

@@ -52,96 +52,64 @@ export class Reader {
      * @param week the week of the current year
      */
     public async loadEntryForWeek(week: Number): Promise<vscode.TextDocument> {
-        return new Promise<vscode.TextDocument>((resolve, reject) => {
-            this.ctrl.logger.trace("Entering loadEntryForWeek() in actions/reader.ts for week " + week);
-
-            let path: string = "";
-
-            Promise.all([
-                this.ctrl.config.getWeekPathPattern(week),
-                this.ctrl.config.getWeekFilePattern(week)
-
-            ]).then(([pathname, filename]) => {
-                path = J.Util.resolvePath(pathname.value!, filename.value!);
-                return this.ctrl.ui.openDocument(path);
-
-            }).catch((reason: any) => {
-                if (reason instanceof Error) {
-                    if (!reason.message.startsWith("cannot open file:")) {
-                        this.ctrl.logger.printError(reason);
-                        reject(reason);
-                    }
-                }
-                return this.ctrl.writer.createWeeklyForPath(path, week);
-
-            }).then((_doc: vscode.TextDocument) => {
-                this.ctrl.logger.debug("loadEntryForWeek() - Loaded file in:", _doc.uri.toString());
-                resolve(_doc);
-
-            }).catch((error: Error) => {
-                this.ctrl.logger.printError(error);
-                reject("Failed to load entry for week: " + week);
-            });
-        });
+        this.ctrl.logger.trace("Entering loadEntryForWeek() in actions/reader.ts for week " + week);
+
+        const [pathname, filename] = await Promise.all([
+            this.ctrl.config.getWeekPathPattern(week),
+            this.ctrl.config.getWeekFilePattern(week),
+        ]);
+        const path = J.Util.resolvePath(pathname.value!, filename.value!);
+
+        const doc = await this.openOrCreate(
+            path,
+            () => this.ctrl.writer.createWeeklyForPath(path, week),
+        );
+        this.ctrl.logger.debug("loadEntryForWeek() - Loaded file in:", doc.uri.toString());
+        return doc;
     }
 
 
     /**
-     * Loads the journal entry for the given date. If no entry exists, promise is rejected with the invalid path
+     * Loads the journal entry for the given date. If no entry exists, it is created.
      *
      * @param {Date} date the date for the entry
-     * @returns {Q.Promise<vscode.TextDocument>} the document
-     * @throws {string} error message
+     * @returns {Promise<vscode.TextDocument>} the document
      * @memberof Reader
      */
-     public async loadEntryForDay(date: Date): Promise<vscode.TextDocument> {
-
-        return new Promise<vscode.TextDocument>((resolve, reject) => {
-            if (J.Util.isNullOrUndefined(date) || date!.toString().includes("Invalid")) {
-                reject("Invalid date");
-                return;
-            }
-
-            this.ctrl.logger.trace("Entering loadEntryforDate() in actions/reader.ts for date " + date.toISOString());
-
-            let path: string = "";
-
-            Promise.all([
-                this.ctrl.config.getResolvedEntryPath(date),
-                this.ctrl.config.getEntryFilePattern(date)
-
-            ]).then(([pathname, filename]) => {
-                path = J.Util.resolvePath(pathname.value!, filename.value!);
-                return this.ctrl.ui.openDocument(path);
-
-
-            }).catch((reason: any) => {
-                if (reason instanceof Error) {
-                    if (!reason.message.startsWith("cannot open file:") && !reason.message.startsWith("cannot open vscode-remote:")) {
-                        this.ctrl.logger.printError(reason);
-                        reject(reason);
-                    }
-                }
-                return this.ctrl.writer.createEntryForPath(path, date);
+    public async loadEntryForDay(date: Date): Promise<vscode.TextDocument> {
+        if (J.Util.isNullOrUndefined(date) || date!.toString().includes("Invalid")) {
+            throw new Error("Invalid date");
+        }
+        this.ctrl.logger.trace("Entering loadEntryforDate() in actions/reader.ts for date " + date.toISOString());
 
-            }).then((_doc: vscode.TextDocument) => {
-                this.ctrl.logger.debug("loadEntryForDate() - Loaded file in:", _doc.uri.toString());
-                new J.Provider.SyncNoteLinks(this.ctrl).injectAttachementLinks(_doc, date)
-                    .finally(() =>
-                        // do nothing
-                        this.ctrl.logger.trace("Scanning notes completed")
-                    );
-                resolve(_doc);
+        const [pathname, filename] = await Promise.all([
+            this.ctrl.config.getResolvedEntryPath(date),
+            this.ctrl.config.getEntryFilePattern(date),
+        ]);
+        const path = J.Util.resolvePath(pathname.value!, filename.value!);
 
-            }).catch((error: Error) => {
-                this.ctrl.logger.printError(error);
-                reject("Failed to load entry for date: " + date.toDateString());
+        const doc = await this.openOrCreate(
+            path,
+            () => this.ctrl.writer.createEntryForPath(path, date),
+        );
+        this.ctrl.logger.debug("loadEntryForDate() - Loaded file in:", doc.uri.toString());
 
-            });
+        new J.Provider.SyncNoteLinks(this.ctrl).injectAttachementLinks(doc, date)
+            .finally(() => this.ctrl.logger.trace("Scanning notes completed"));
 
-        });
+        return doc;
     }
 
+    private async openOrCreate(
+        path: string,
+        create: () => Promise<vscode.TextDocument>,
+    ): Promise<vscode.TextDocument> {
+        const exists = await J.Util.fileExists(vscode.Uri.file(path));
+        if (exists) {
+            return this.ctrl.ui.openDocument(path);
+        }
+        return create();
+    }
 }
 
 

src/provider/features/load-note.ts

@@ -32,31 +32,21 @@ export class LoadNotes {
     } 
 
       /**
-     * Creates or loads a note 
+     * Creates or loads a note
      *
      * @param {string} path
      * @param {string} content
      * @returns {Promise<vscode.TextDocument>}
      * @memberof Writer
      */
-       public async loadNote(path: string, content: string): Promise<vscode.TextDocument> {
+    public async loadNote(path: string, content: string): Promise<vscode.TextDocument> {
         this.ctrl.logger.trace("Entering loadNote() in  features/load-note.ts for path: ", path);
 
-        return new Promise<vscode.TextDocument>((resolve, reject) => {
-            // check if file exists already
-
-            this.ctrl.ui.openDocument(path)
-                .then((doc: vscode.TextDocument) => resolve(doc))
-                .catch(error => {
-                    this.ctrl.writer.createSaveLoadTextDocument(path, content)
-                        .then((doc: vscode.TextDocument) => resolve(doc))
-                        .catch(error => {
-                            this.ctrl.logger.error(error);
-                            reject("Failed to load note.");
-                        });
-                });
-
-        });
+        const exists = await J.Util.fileExists(vscode.Uri.file(path));
+        if (exists) {
+            return this.ctrl.ui.openDocument(path);
+        }
+        return this.ctrl.writer.createSaveLoadTextDocument(path, content);
     }
 
 

src/util/fs-exists.ts

@@ -0,0 +1,35 @@
+// Copyright (C) 2026  Patrick Maué
+//
+// This file is part of vscode-journal.
+//
+// vscode-journal is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// vscode-journal is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with vscode-journal.  If not, see <http://www.gnu.org/licenses/>.
+
+'use strict';
+
+import * as vscode from 'vscode';
+
+// Returns true if the URI resolves to an existing entry on the workspace
+// filesystem, false if it definitely does not exist, and rethrows for any
+// other FS error so callers (and VS Code) can surface a notification.
+export async function fileExists(uri: vscode.Uri): Promise<boolean> {
+    try {
+        await vscode.workspace.fs.stat(uri);
+        return true;
+    } catch (err) {
+        if (err instanceof vscode.FileSystemError && err.code === 'FileNotFound') {
+            return false;
+        }
+        throw err;
+    }
+}

src/util/index.ts

@@ -51,4 +51,5 @@ export {
     getPathOfMonth,
     inferType,
     resolvePath,
-} from './paths';
+} from './paths';
+export { fileExists } from './fs-exists';