@bobfrankston/rmfmail 1.0.503 → 1.0.505

package/packages/mailx-store/file-store.ts

@@ -21,46 +21,91 @@ export class FileMessageStore implements MessageStore {
         fs.mkdirSync(basePath, { recursive: true });
     }
 
-    /** Fresh opaque path per call. No inputs from the caller affect the name. */
-    private newMessagePath(accountId: string): string {
+    /** Fresh opaque path per call, returned RELATIVE to `basePath`. The DB
+     *  stores this relative form so the body store can be relocated (or
+     *  the user folder renamed — e.g. `.mailx → .rmfmail`) without the
+     *  body_path entries breaking. */
+    private newRelativePath(accountId: string): string {
         const uuid = randomUUID().replace(/-/g, "");
         const prefix = uuid.slice(0, 2);
-        return path.join(this.basePath, accountId, prefix, `${uuid}.eml`);
+        return path.join(accountId, prefix, `${uuid}.eml`);
     }
 
-    /** Verify a given path resolves inside this store's basePath — refuses
-     *  any value that doesn't (cheap directory-traversal guard). */
-    private inStore(fullPath: string): boolean {
-        if (!fullPath) return false;
-        const rel = path.relative(path.resolve(this.basePath), path.resolve(fullPath));
-        return !rel.startsWith("..") && !path.isAbsolute(rel);
+    /** Resolve a stored path. Accepts either a relative path (post-2026-05
+     *  format) or an absolute path (legacy entries until next-launch
+     *  migration rewrites them). Either way, refuse anything outside the
+     *  store as a directory-traversal guard. */
+    private resolveStored(p: string): string {
+        if (!p) return "";
+        const abs = path.isAbsolute(p) ? p : path.resolve(this.basePath, p);
+        const rel = path.relative(path.resolve(this.basePath), abs);
+        if (rel.startsWith("..") || path.isAbsolute(rel)) return "";
+        return abs;
     }
 
-    /** Write a new body. Always a fresh UUID path. Caller MUST persist the
-     *  returned path in the DB (`body_path`) and use it for all reads. The
-     *  (folderId, uid) args are kept for interface compatibility; they do
-     *  NOT affect the filename. */
+    /** Write a new body. Returns a path RELATIVE to basePath; caller stores
+     *  it in `body_path`. The (folderId, uid) args are kept for interface
+     *  compatibility; they do NOT affect the filename. */
     async putMessage(accountId: string, _folderId: number, _uid: number, raw: Buffer): Promise<string> {
-        const filePath = this.newMessagePath(accountId);
-        fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        fs.writeFileSync(filePath, raw);
-        return filePath;
+        const rel = this.newRelativePath(accountId);
+        const abs = path.join(this.basePath, rel);
+        fs.mkdirSync(path.dirname(abs), { recursive: true });
+        fs.writeFileSync(abs, raw);
+        return rel;
     }
 
-    /** Read by absolute path (DB `body_path`). The primary read API. */
-    async readByPath(fullPath: string): Promise<Buffer> {
-        if (!this.inStore(fullPath)) throw new Error(`refusing to read outside store: ${fullPath}`);
-        return fs.readFileSync(fullPath);
+    /** Read by stored path (relative or absolute). */
+    async readByPath(stored: string): Promise<Buffer> {
+        const abs = this.resolveStored(stored);
+        if (!abs) throw new Error(`refusing to read outside store: ${stored}`);
+        return fs.readFileSync(abs);
     }
 
-    async hasByPath(fullPath: string): Promise<boolean> {
-        if (!this.inStore(fullPath)) return false;
-        return fs.existsSync(fullPath);
+    async hasByPath(stored: string): Promise<boolean> {
+        const abs = this.resolveStored(stored);
+        return !!abs && fs.existsSync(abs);
     }
 
-    async unlinkByPath(fullPath: string): Promise<void> {
-        if (!this.inStore(fullPath)) return;
-        if (fs.existsSync(fullPath)) fs.unlinkSync(fullPath);
+    async unlinkByPath(stored: string): Promise<void> {
+        const abs = this.resolveStored(stored);
+        if (!abs) return;
+        if (fs.existsSync(abs)) fs.unlinkSync(abs);
+    }
+
+    /** One-shot migration: rewrite absolute body_path values that point at
+     *  this store's basePath into relative form. Called once from db.ts on
+     *  startup (gated by a kv flag); silently skipped after first run.
+     *  Returns the count of rewritten paths.
+     *
+     *  Bodies whose absolute path is OUTSIDE basePath (the legacy
+     *  `~/.mailx/mailxstore/...` entries on a machine where basePath is
+     *  now `~/.rmfmail/mailxstore`) are left alone — the migration in
+     *  mailx-settings already moves the files; this rewrite is purely
+     *  about getting body_path to a relative shape. */
+    rewriteAbsoluteToRelative(rows: Array<{ id: number; body_path: string }>,
+                               update: (id: number, newPath: string) => void): number {
+        let n = 0;
+        const baseAbs = path.resolve(this.basePath);
+        for (const r of rows) {
+            if (!r.body_path || !path.isAbsolute(r.body_path)) continue;
+            const rel = path.relative(baseAbs, path.resolve(r.body_path));
+            if (rel.startsWith("..") || path.isAbsolute(rel)) {
+                // Outside this store — try mapping `.mailx → .rmfmail` if the
+                // legacy dir was the source. Then re-test.
+                const remapped = r.body_path.replace(/[\\/]\.mailx[\\/]mailxstore[\\/]/i, `${path.sep}.rmfmail${path.sep}mailxstore${path.sep}`);
+                if (remapped !== r.body_path) {
+                    const rel2 = path.relative(baseAbs, path.resolve(remapped));
+                    if (!rel2.startsWith("..") && !path.isAbsolute(rel2)) {
+                        update(r.id, rel2.replace(/\\/g, "/"));
+                        n++;
+                    }
+                }
+                continue;
+            }
+            update(r.id, rel.replace(/\\/g, "/"));
+            n++;
+        }
+        return n;
     }
 
     // MessageStore interface compatibility (unused once all callers migrate to