sfora-cli 0.1.0

package/dist/SforaFs.js

@@ -0,0 +1,762 @@
+/**
+ * A {@link IFileSystem} backed by sfora's `/v1/fs` HTTP API. Posts appear as a
+ * Unix tree:
+ *
+ *   /
+ *   ├── projects/<slug>/posts/<YYYY-MM-DD-title>.md   (lazy → GET …/posts/…)
+ *   │                  /drafts/<…>.md                 (lazy → GET …/drafts/…)
+ *   ├── inbox/mentions.md                             (lazy → GET …/inbox)
+ *   └── me/api-key                                    (lazy → GET …/me/api-key)
+ *
+ * Reads are lazy: directory listings hit the API (cached ~5s so back-to-back
+ * `ls && cat` doesn't double-fetch), and file bodies are only fetched when read.
+ * Writes `PUT` markdown; `rm` of a post file soft-deletes it. Everything else
+ * (symlinks, cross-file cp/mv, mkdir of new projects) is denied to match the
+ * read/append/create surface the backend actually supports.
+ *
+ * Error messages follow the `ERRNO: text, op 'path'` convention just-bash maps
+ * back onto shell-visible errors.
+ */
+import { SforaApiError, } from "./api-client.js";
+const DIR_MODE = 0o755;
+const FILE_MODE = 0o644;
+const LIST_TTL_MS = 5_000;
+// ─── Path helpers (pure, no I/O) ───────────────────────────────────
+function normalize(path) {
+    if (!path || path === "/")
+        return "/";
+    let p = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+    if (!p.startsWith("/"))
+        p = `/${p}`;
+    const out = [];
+    for (const part of p.split("/")) {
+        if (!part || part === ".")
+            continue;
+        if (part === "..")
+            out.pop();
+        else
+            out.push(part);
+    }
+    return `/${out.join("/")}`;
+}
+function segments(path) {
+    return normalize(path)
+        .split("/")
+        .filter((s) => s.length > 0);
+}
+/** Strip `.md` and an optional `YYYY-MM-DD-` date prefix to get the slug part. */
+function fileSlug(name) {
+    const base = name.endsWith(".md") ? name.slice(0, -3) : name;
+    return base.replace(/^\d{4}-\d{2}-\d{2}-/, "");
+}
+function classify(path) {
+    const seg = segments(path);
+    if (seg.length === 0)
+        return { kind: "root" };
+    if (seg.length === 1) {
+        if (seg[0] === "projects")
+            return { kind: "projectsDir" };
+        if (seg[0] === "inbox")
+            return { kind: "inboxDir" };
+        if (seg[0] === "me")
+            return { kind: "meDir" };
+        return { kind: "unknown", path: normalize(path) };
+    }
+    if (seg[0] === "inbox" && seg[1] === "mentions.md" && seg.length === 2) {
+        return { kind: "inboxFile" };
+    }
+    if (seg[0] === "me" && seg[1] === "api-key" && seg.length === 2) {
+        return { kind: "meFile" };
+    }
+    if (seg[0] === "projects") {
+        const slug = seg[1];
+        if (seg.length === 2)
+            return { kind: "projectDir", slug };
+        const dir = seg[2];
+        if (dir === "posts" || dir === "drafts") {
+            if (seg.length === 3)
+                return { kind: "postsDir", slug, dir };
+            if (seg.length === 4) {
+                return { kind: "postFile", slug, dir, filename: seg[3] };
+            }
+        }
+        if (dir === "board") {
+            if (seg.length === 3)
+                return { kind: "boardDir", slug };
+            if (seg.length === 4) {
+                return { kind: "boardColumnDir", slug, column: seg[3] };
+            }
+            if (seg.length === 5) {
+                return {
+                    kind: "boardCardFile",
+                    slug,
+                    column: seg[3],
+                    filename: seg[4],
+                };
+            }
+        }
+    }
+    return { kind: "unknown", path: normalize(path) };
+}
+// ─── errno-flavoured errors ────────────────────────────────────────
+const err = (code, text, op, path) => new Error(`${code}: ${text}, ${op} '${path}'`);
+const enoent = (op, p) => err("ENOENT", "no such file or directory", op, p);
+const enotdir = (op, p) => err("ENOTDIR", "not a directory", op, p);
+const eisdir = (op, p) => err("EISDIR", "illegal operation on a directory", op, p);
+const eacces = (op, p) => err("EACCES", "permission denied", op, p);
+const eperm = (op, p) => err("EPERM", "operation not permitted", op, p);
+/** Map an API failure onto a filesystem-shaped error for `op` at `path`. */
+function fromApi(e, op, path) {
+    if (e instanceof SforaApiError) {
+        if (e.status === 404)
+            return enoent(op, path);
+        if (e.status === 401 || e.status === 403)
+            return eacces(op, path);
+        if (e.status === 0)
+            return new Error(`${op} '${path}': ${e.message}`);
+        return new Error(`${op} '${path}': ${e.message}`);
+    }
+    return e instanceof Error ? e : new Error(String(e));
+}
+function toText(content) {
+    return typeof content === "string" ? content : new TextDecoder().decode(content);
+}
+function toNodeEncoding(enc) {
+    if (enc === "utf-8")
+        return "utf8";
+    if (enc === "binary")
+        return "latin1";
+    return enc;
+}
+function readEncoding(options) {
+    if (typeof options === "string")
+        return options;
+    return options?.encoding ?? "utf8";
+}
+export class SforaFs {
+    #client;
+    #cache = new Map();
+    // Sync snapshots for getAllPaths() (glob support) — updated as lists resolve.
+    #projectSlugs = [];
+    #entrySnapshots = new Map();
+    constructor(client) {
+        this.#client = client;
+    }
+    // ─── caching ─────────────────────────────────────────────────────
+    #cached(key, loader) {
+        const now = Date.now();
+        const hit = this.#cache.get(key);
+        if (hit && now - hit.at < LIST_TTL_MS)
+            return hit.value;
+        const value = loader();
+        this.#cache.set(key, { at: now, value });
+        // Drop failed loads so the next access retries instead of caching the error.
+        value.catch(() => {
+            if (this.#cache.get(key)?.value === value)
+                this.#cache.delete(key);
+        });
+        return value;
+    }
+    #listProjects() {
+        return this.#cached("projects", async () => {
+            const projects = await this.#client.listProjects();
+            this.#projectSlugs = projects.map((p) => p.slug);
+            return projects;
+        });
+    }
+    #listEntries(slug, dir) {
+        const key = `${dir}:${slug}`;
+        return this.#cached(key, async () => {
+            const entries = await this.#client.listPosts(slug, dir);
+            this.#entrySnapshots.set(`/projects/${slug}/${dir}`, entries.map((e) => e.filename));
+            return entries;
+        });
+    }
+    #invalidate(slug, dir) {
+        this.#cache.delete(`${dir}:${slug}`);
+        this.#cache.delete("projects"); // postCount changes
+    }
+    // ─── board caches ────────────────────────────────────────────────
+    #listColumns(slug) {
+        const key = `columns:${slug}`;
+        return this.#cached(key, async () => {
+            const columns = await this.#client.listColumns(slug);
+            this.#entrySnapshots.set(`/projects/${slug}/board`, columns.map((c) => c.dirname));
+            return columns;
+        });
+    }
+    #listCards(slug, column) {
+        const key = `cards:${slug}/${column}`;
+        return this.#cached(key, async () => {
+            const cards = await this.#client.listCards(slug, column);
+            this.#entrySnapshots.set(`/projects/${slug}/board/${column}`, cards.map((c) => c.filename));
+            return cards;
+        });
+    }
+    #invalidateBoard(slug, column) {
+        this.#cache.delete(`columns:${slug}`);
+        if (column)
+            this.#cache.delete(`cards:${slug}/${column}`);
+        else {
+            // Nuke every cards:<slug>/* entry — a column rename/delete affects many.
+            for (const k of this.#cache.keys()) {
+                if (k.startsWith(`cards:${slug}/`))
+                    this.#cache.delete(k);
+            }
+        }
+    }
+    async #columnExists(slug, column) {
+        const cols = await this.#listColumns(slug);
+        return cols.some((c) => c.dirname === column);
+    }
+    async #matchCard(slug, column, filename) {
+        const cards = await this.#listCards(slug, column);
+        // Try exact filename first; fall back to matching by card number prefix
+        // (`42-anything.md` → card #42), then by slug (`three.md` → `NNNN-three.md`).
+        // Mirrors matchCardByFilename in convex/httpHelpers.ts so an agent typing
+        // `mv three.md …` works even though listings return `0035-three.md`.
+        const exact = cards.find((c) => c.filename === filename);
+        if (exact)
+            return exact;
+        const numMatch = /^(\d+)(?:-|\.)/.exec(filename);
+        if (numMatch) {
+            const n = Number.parseInt(numMatch[1], 10);
+            const byNum = cards.find((c) => c.number === n);
+            if (byNum)
+                return byNum;
+        }
+        const wantSlug = filename
+            .replace(/\.md$/i, "")
+            .replace(/^\d+-/, "")
+            .toLowerCase();
+        return cards.find((c) => c.filename
+            .replace(/\.md$/i, "")
+            .replace(/^\d+-/, "")
+            .toLowerCase() === wantSlug);
+    }
+    async #projectExists(slug) {
+        const projects = await this.#listProjects();
+        return projects.some((p) => p.slug === slug);
+    }
+    async #matchEntry(slug, dir, filename) {
+        const entries = await this.#listEntries(slug, dir);
+        const want = fileSlug(filename);
+        return (entries.find((e) => e.filename === filename) ??
+            entries.find((e) => fileSlug(e.filename) === want));
+    }
+    // ─── reads ───────────────────────────────────────────────────────
+    async #readText(path) {
+        const loc = classify(path);
+        switch (loc.kind) {
+            case "postFile":
+                try {
+                    return await this.#client.readPost(loc.slug, loc.filename, loc.dir);
+                }
+                catch (e) {
+                    throw fromApi(e, "open", normalize(path));
+                }
+            case "boardCardFile":
+                try {
+                    return await this.#client.readCard(loc.slug, loc.column, loc.filename);
+                }
+                catch (e) {
+                    throw fromApi(e, "open", normalize(path));
+                }
+            case "inboxFile":
+                try {
+                    return await this.#client.readInbox();
+                }
+                catch (e) {
+                    throw fromApi(e, "open", normalize(path));
+                }
+            case "meFile":
+                try {
+                    return await this.#client.readMe();
+                }
+                catch (e) {
+                    throw fromApi(e, "open", normalize(path));
+                }
+            case "root":
+            case "projectsDir":
+            case "inboxDir":
+            case "meDir":
+            case "projectDir":
+            case "postsDir":
+            case "boardDir":
+            case "boardColumnDir":
+                throw eisdir("read", normalize(path));
+            default:
+                throw enoent("open", normalize(path));
+        }
+    }
+    async readFile(path, options) {
+        const text = await this.#readText(path);
+        const enc = readEncoding(options);
+        if (enc === "utf8" || enc === "utf-8")
+            return text;
+        return Buffer.from(text, "utf8").toString(toNodeEncoding(enc));
+    }
+    async readFileBuffer(path) {
+        const text = await this.#readText(path);
+        return new TextEncoder().encode(text);
+    }
+    async writeFile(path, content, _options) {
+        const loc = classify(path);
+        const norm = normalize(path);
+        if (loc.kind === "inboxFile" || loc.kind === "meFile") {
+            throw eacces("open", norm);
+        }
+        if (loc.kind === "root" ||
+            loc.kind === "projectsDir" ||
+            loc.kind === "inboxDir" ||
+            loc.kind === "meDir" ||
+            loc.kind === "projectDir" ||
+            loc.kind === "postsDir" ||
+            loc.kind === "boardDir" ||
+            loc.kind === "boardColumnDir") {
+            throw eisdir("open", norm);
+        }
+        if (loc.kind === "postFile") {
+            try {
+                await this.#client.writePost(loc.slug, loc.dir, loc.filename, toText(content));
+            }
+            catch (e) {
+                throw fromApi(e, "open", norm);
+            }
+            this.#invalidate(loc.slug, loc.dir);
+            return;
+        }
+        if (loc.kind === "boardCardFile") {
+            try {
+                const res = await this.#client.writeCard(loc.slug, loc.column, loc.filename, toText(content));
+                // If the server relocated the card (frontmatter `column:` changed),
+                // invalidate both columns.
+                this.#invalidateBoard(loc.slug, loc.column);
+                if (res.movedTo && res.movedTo !== loc.column) {
+                    this.#invalidateBoard(loc.slug, res.movedTo);
+                }
+            }
+            catch (e) {
+                throw fromApi(e, "open", norm);
+            }
+            return;
+        }
+        // Writes only land under projects/<slug>/(posts|drafts|board/<col>).
+        throw eacces("open", norm);
+    }
+    async appendFile(path, content, options) {
+        let existing = "";
+        if (await this.exists(path)) {
+            existing = await this.#readText(path);
+        }
+        await this.writeFile(path, existing + toText(content), options);
+    }
+    async exists(path) {
+        const loc = classify(path);
+        try {
+            switch (loc.kind) {
+                case "root":
+                case "projectsDir":
+                case "inboxDir":
+                case "meDir":
+                case "inboxFile":
+                case "meFile":
+                    return true;
+                case "projectDir":
+                case "postsDir":
+                case "boardDir":
+                    return await this.#projectExists(loc.slug);
+                case "boardColumnDir":
+                    return ((await this.#projectExists(loc.slug)) &&
+                        (await this.#columnExists(loc.slug, loc.column)));
+                case "postFile":
+                    return (await this.#matchEntry(loc.slug, loc.dir, loc.filename)) !==
+                        undefined;
+                case "boardCardFile":
+                    return ((await this.#matchCard(loc.slug, loc.column, loc.filename)) !==
+                        undefined);
+                default:
+                    return false;
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    #dirStat() {
+        return {
+            isFile: false,
+            isDirectory: true,
+            isSymbolicLink: false,
+            mode: DIR_MODE,
+            size: 0,
+            mtime: new Date(),
+        };
+    }
+    #fileStat(mtime, size = 0) {
+        return {
+            isFile: true,
+            isDirectory: false,
+            isSymbolicLink: false,
+            mode: FILE_MODE,
+            size,
+            mtime,
+        };
+    }
+    async stat(path) {
+        const loc = classify(path);
+        const norm = normalize(path);
+        try {
+            switch (loc.kind) {
+                case "root":
+                case "projectsDir":
+                case "inboxDir":
+                case "meDir":
+                    return this.#dirStat();
+                case "inboxFile":
+                case "meFile":
+                    return this.#fileStat(new Date());
+                case "projectDir":
+                case "postsDir":
+                case "boardDir":
+                    if (!(await this.#projectExists(loc.slug)))
+                        throw enoent("stat", norm);
+                    return this.#dirStat();
+                case "boardColumnDir":
+                    if (!(await this.#projectExists(loc.slug)))
+                        throw enoent("stat", norm);
+                    if (!(await this.#columnExists(loc.slug, loc.column))) {
+                        throw enoent("stat", norm);
+                    }
+                    return this.#dirStat();
+                case "postFile": {
+                    const entry = await this.#matchEntry(loc.slug, loc.dir, loc.filename);
+                    if (!entry)
+                        throw enoent("stat", norm);
+                    return this.#fileStat(new Date(entry.publishedAt || Date.now()));
+                }
+                case "boardCardFile": {
+                    const card = await this.#matchCard(loc.slug, loc.column, loc.filename);
+                    if (!card)
+                        throw enoent("stat", norm);
+                    return this.#fileStat(new Date(card.lastActivityAt || Date.now()));
+                }
+                default:
+                    throw enoent("stat", norm);
+            }
+        }
+        catch (e) {
+            throw fromApi(e, "stat", norm);
+        }
+    }
+    lstat(path) {
+        // No symlinks in this filesystem, so lstat == stat.
+        return this.stat(path);
+    }
+    // ─── directories ─────────────────────────────────────────────────
+    async readdirWithFileTypes(path) {
+        const loc = classify(path);
+        const norm = normalize(path);
+        const dirent = (name, isDir) => ({
+            name,
+            isFile: !isDir,
+            isDirectory: isDir,
+            isSymbolicLink: false,
+        });
+        try {
+            switch (loc.kind) {
+                case "root":
+                    return [
+                        dirent("inbox", true),
+                        dirent("me", true),
+                        dirent("projects", true),
+                    ];
+                case "projectsDir": {
+                    const projects = await this.#listProjects();
+                    return projects
+                        .map((p) => p.slug)
+                        .sort()
+                        .map((s) => dirent(s, true));
+                }
+                case "inboxDir":
+                    return [dirent("mentions.md", false)];
+                case "meDir":
+                    return [dirent("api-key", false)];
+                case "projectDir":
+                    if (!(await this.#projectExists(loc.slug))) {
+                        throw enoent("scandir", norm);
+                    }
+                    return [
+                        dirent("board", true),
+                        dirent("drafts", true),
+                        dirent("posts", true),
+                    ];
+                case "postsDir": {
+                    const entries = await this.#listEntries(loc.slug, loc.dir);
+                    return entries.map((e) => dirent(e.filename, false));
+                }
+                case "boardDir": {
+                    if (!(await this.#projectExists(loc.slug))) {
+                        throw enoent("scandir", norm);
+                    }
+                    const cols = await this.#listColumns(loc.slug);
+                    return cols
+                        .slice()
+                        .sort((a, b) => a.position - b.position)
+                        .map((c) => dirent(c.dirname, true));
+                }
+                case "boardColumnDir": {
+                    if (!(await this.#columnExists(loc.slug, loc.column))) {
+                        throw enoent("scandir", norm);
+                    }
+                    const cards = await this.#listCards(loc.slug, loc.column);
+                    return cards.map((c) => dirent(c.filename, false));
+                }
+                case "inboxFile":
+                case "meFile":
+                case "postFile":
+                case "boardCardFile":
+                    throw enotdir("scandir", norm);
+                default:
+                    throw enoent("scandir", norm);
+            }
+        }
+        catch (e) {
+            throw fromApi(e, "scandir", norm);
+        }
+    }
+    async readdir(path) {
+        const entries = await this.readdirWithFileTypes(path);
+        return entries.map((e) => e.name);
+    }
+    async mkdir(path, _options) {
+        const loc = classify(path);
+        const norm = normalize(path);
+        switch (loc.kind) {
+            // Known structural directories already exist — mkdir is a no-op.
+            case "root":
+            case "projectsDir":
+            case "inboxDir":
+            case "meDir":
+                return;
+            case "projectDir":
+            case "postsDir":
+            case "boardDir":
+                if (await this.#projectExists(loc.slug))
+                    return;
+                throw eacces("mkdir", norm);
+            case "boardColumnDir": {
+                if (!(await this.#projectExists(loc.slug)))
+                    throw eacces("mkdir", norm);
+                // Already exists — no-op.
+                if (await this.#columnExists(loc.slug, loc.column))
+                    return;
+                try {
+                    // Strip the NN-prefix to derive the human-readable name; the server
+                    // re-slugifies and assigns the position.
+                    const name = loc.column.replace(/^\d+-/, "").replace(/-/g, " ");
+                    await this.#client.createColumn(loc.slug, name || loc.column);
+                }
+                catch (e) {
+                    throw fromApi(e, "mkdir", norm);
+                }
+                this.#invalidateBoard(loc.slug);
+                return;
+            }
+            default:
+                // Can't create new projects / arbitrary dirs through the fs.
+                throw eacces("mkdir", norm);
+        }
+    }
+    // ─── removal (rm = unlink → soft delete) ───────────────────────────
+    async rm(path, options) {
+        const loc = classify(path);
+        const norm = normalize(path);
+        switch (loc.kind) {
+            case "postFile": {
+                const exists = (await this.#matchEntry(loc.slug, loc.dir, loc.filename)) !==
+                    undefined;
+                if (!exists) {
+                    if (options?.force)
+                        return;
+                    throw enoent("unlink", norm);
+                }
+                try {
+                    await this.#client.deletePost(loc.slug, loc.dir, loc.filename);
+                }
+                catch (e) {
+                    throw fromApi(e, "unlink", norm);
+                }
+                this.#invalidate(loc.slug, loc.dir);
+                return;
+            }
+            case "boardCardFile": {
+                const card = await this.#matchCard(loc.slug, loc.column, loc.filename);
+                if (!card) {
+                    if (options?.force)
+                        return;
+                    throw enoent("unlink", norm);
+                }
+                try {
+                    await this.#client.deleteCard(loc.slug, loc.column, card.filename);
+                }
+                catch (e) {
+                    throw fromApi(e, "unlink", norm);
+                }
+                this.#invalidateBoard(loc.slug, loc.column);
+                return;
+            }
+            case "boardColumnDir": {
+                // `rmdir`/`rm -r` on a column → delete the column. Server enforces
+                // empty unless we'd want to add a force-cascade, which we don't.
+                if (!(await this.#columnExists(loc.slug, loc.column))) {
+                    if (options?.force)
+                        return;
+                    throw enoent("unlink", norm);
+                }
+                try {
+                    await this.#client.deleteColumn(loc.slug, loc.column);
+                }
+                catch (e) {
+                    throw fromApi(e, "unlink", norm);
+                }
+                this.#invalidateBoard(loc.slug);
+                return;
+            }
+            case "inboxFile":
+            case "meFile":
+                throw eacces("unlink", norm);
+            case "root":
+            case "projectsDir":
+            case "inboxDir":
+            case "meDir":
+            case "projectDir":
+            case "postsDir":
+            case "boardDir":
+                // Top-level structural dirs can't be removed.
+                if (options?.recursive)
+                    throw eperm("rm", norm);
+                throw eisdir("unlink", norm);
+            default:
+                if (options?.force)
+                    return;
+                throw enoent("unlink", norm);
+        }
+    }
+    // ─── unsupported mutations ─────────────────────────────────────────
+    cp(src, _dest, _options) {
+        return Promise.reject(eperm("cp", normalize(src)));
+    }
+    async mv(src, dest) {
+        const srcLoc = classify(src);
+        const destLoc = classify(dest);
+        const srcNorm = normalize(src);
+        const destNorm = normalize(dest);
+        // Card moves: /board/A/x.md → /board/B/x.md (or /board/B/, which keeps the
+        // filename). Body and metadata stay; only the column changes.
+        if (srcLoc.kind === "boardCardFile") {
+            let targetColumn;
+            if (destLoc.kind === "boardCardFile") {
+                if (destLoc.slug !== srcLoc.slug) {
+                    throw eperm("rename", srcNorm);
+                }
+                targetColumn = destLoc.column;
+            }
+            else if (destLoc.kind === "boardColumnDir") {
+                if (destLoc.slug !== srcLoc.slug) {
+                    throw eperm("rename", srcNorm);
+                }
+                targetColumn = destLoc.column;
+            }
+            else {
+                throw eperm("rename", srcNorm);
+            }
+            const card = await this.#matchCard(srcLoc.slug, srcLoc.column, srcLoc.filename);
+            if (!card)
+                throw enoent("rename", srcNorm);
+            // Same column → no-op (avoid a roundtrip when an agent re-`mv`s in place).
+            if (targetColumn === srcLoc.column)
+                return;
+            if (!(await this.#columnExists(srcLoc.slug, targetColumn))) {
+                throw enoent("rename", destNorm);
+            }
+            try {
+                await this.#client.moveCard(srcLoc.slug, srcLoc.column, card.filename, targetColumn);
+            }
+            catch (e) {
+                throw fromApi(e, "rename", srcNorm);
+            }
+            this.#invalidateBoard(srcLoc.slug, srcLoc.column);
+            this.#invalidateBoard(srcLoc.slug, targetColumn);
+            return;
+        }
+        // Column renames: /board/old → /board/new (same project). Strips the NN-
+        // prefix to derive the new human-readable name; server picks a fresh prefix
+        // to preserve position.
+        if (srcLoc.kind === "boardColumnDir" && destLoc.kind === "boardColumnDir") {
+            if (srcLoc.slug !== destLoc.slug)
+                throw eperm("rename", srcNorm);
+            if (!(await this.#columnExists(srcLoc.slug, srcLoc.column))) {
+                throw enoent("rename", srcNorm);
+            }
+            const name = destLoc.column.replace(/^\d+-/, "").replace(/-/g, " ");
+            try {
+                await this.#client.renameColumn(srcLoc.slug, srcLoc.column, name);
+            }
+            catch (e) {
+                throw fromApi(e, "rename", srcNorm);
+            }
+            this.#invalidateBoard(srcLoc.slug);
+            return;
+        }
+        throw eperm("rename", srcNorm);
+    }
+    symlink(_target, linkPath) {
+        return Promise.reject(eperm("symlink", normalize(linkPath)));
+    }
+    link(_existingPath, newPath) {
+        return Promise.reject(eperm("link", normalize(newPath)));
+    }
+    readlink(path) {
+        return Promise.reject(err("EINVAL", "invalid argument", "readlink", normalize(path)));
+    }
+    // ─── trivial / pure ────────────────────────────────────────────────
+    resolvePath(base, path) {
+        if (path.startsWith("/"))
+            return normalize(path);
+        return normalize(base === "/" ? `/${path}` : `${base}/${path}`);
+    }
+    realpath(path) {
+        // No symlinks — the canonical path is just the normalized one.
+        return Promise.resolve(normalize(path));
+    }
+    getAllPaths() {
+        const paths = new Set([
+            "/",
+            "/projects",
+            "/inbox",
+            "/me",
+            "/inbox/mentions.md",
+            "/me/api-key",
+        ]);
+        for (const slug of this.#projectSlugs) {
+            paths.add(`/projects/${slug}`);
+            paths.add(`/projects/${slug}/posts`);
+            paths.add(`/projects/${slug}/drafts`);
+            paths.add(`/projects/${slug}/board`);
+        }
+        for (const [dirPath, filenames] of this.#entrySnapshots) {
+            for (const name of filenames)
+                paths.add(`${dirPath}/${name}`);
+        }
+        return [...paths];
+    }
+    chmod(_path, _mode) {
+        // Permissions are virtual; accept and ignore.
+        return Promise.resolve();
+    }
+    utimes(_path, _atime, _mtime) {
+        // mtime is server-owned; accept and ignore.
+        return Promise.resolve();
+    }
+}