brains-mcp 1.61.2

package/dist/storage/client.js

@@ -0,0 +1,825 @@
+import fs from "fs/promises";
+import path from "path";
+import crypto from "crypto";
+import { DriveAuthError, DriveConflictError, DriveNotFoundError, DrivePermissionError, } from "../drive/errors.js";
+const MAX_FILE_SIZE_BYTES = 2 * 1024 * 1024;
+const PROTECTED_ROOT_FOLDERS = new Set([
+    "instructions",
+    "canonical",
+    "data",
+    "decisions",
+    "history",
+    "projects",
+]);
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function contentRevision(content) {
+    return crypto.createHash("sha256").update(content, "utf8").digest("hex").slice(0, 16);
+}
+function isEnoent(err) {
+    return err?.code === "ENOENT";
+}
+function normalizeWikiPath(name) {
+    const normalized = name.replace(/\\/g, "/");
+    const segments = normalized.split("/");
+    if (path.isAbsolute(name) ||
+        normalized.startsWith("/") ||
+        segments.some((s) => s.length === 0 || s === "." || s === "..")) {
+        throw new DrivePermissionError(`Unsafe filename rejected: '${name}'`);
+    }
+    for (const segment of segments.slice(0, -1)) {
+        if (!/^[a-z0-9-]+$/.test(segment)) {
+            throw new DrivePermissionError(`Unsafe path segment rejected: '${segment}' in '${name}'`);
+        }
+    }
+    const last = segments[segments.length - 1] ?? "";
+    if (!/^[a-z0-9-]+\.md$/.test(last)) {
+        throw new DrivePermissionError(`Unsafe filename rejected: '${last}' in '${name}'`);
+    }
+    return normalized;
+}
+function combinePosixPrefix(base, suffix) {
+    const a = base.trim().replace(/^\/+|\/+$/g, "");
+    const b = suffix.trim().replace(/^\/+|\/+$/g, "");
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    return `${a}/${b}`;
+}
+function encodePathSegments(value) {
+    return value
+        .split("/")
+        .filter((segment) => segment.length > 0)
+        .map((segment) => encodeURIComponent(segment))
+        .join("/");
+}
+// ─── LocalClient ─────────────────────────────────────────────────────────────
+export class LocalClient {
+    wikiDir;
+    backup;
+    constructor(wikiDir, backup = null) {
+        this.wikiDir = path.resolve(wikiDir);
+        this.backup = backup;
+    }
+    getStorageLocation() {
+        return this.wikiDir;
+    }
+    async verifyAccess() {
+        try {
+            await fs.mkdir(this.wikiDir, { recursive: true });
+            await fs.access(this.wikiDir, fs.constants.R_OK | fs.constants.W_OK);
+        }
+        catch (err) {
+            throw new DriveAuthError(`Cannot access wiki directory '${this.wikiDir}': ${err}`);
+        }
+    }
+    async fileExists(name) {
+        this.assertSafePath(name);
+        return fs.stat(path.join(this.wikiDir, name)).then(() => true).catch(() => false);
+    }
+    async listFiles() {
+        await fs.mkdir(this.wikiDir, { recursive: true });
+        const results = [];
+        const walk = async (relativeDir) => {
+            const dirPath = path.join(this.wikiDir, relativeDir);
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            for (const e of entries) {
+                const relPath = relativeDir ? path.posix.join(relativeDir, e.name) : e.name;
+                if (e.isDirectory()) {
+                    await walk(relPath);
+                    continue;
+                }
+                if (!e.isFile() || !relPath.endsWith(".md"))
+                    continue;
+                try {
+                    const stat = await fs.stat(path.join(this.wikiDir, relPath));
+                    results.push({
+                        fileId: relPath,
+                        name: relPath,
+                        modifiedTime: stat.mtime.toISOString(),
+                        size: stat.size,
+                    });
+                }
+                catch {
+                    // skip unreadable entries
+                }
+            }
+        };
+        await walk("");
+        return results.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async readFile(name) {
+        this.assertSafePath(name);
+        const filePath = path.join(this.wikiDir, name);
+        try {
+            const [content, stat] = await Promise.all([
+                fs.readFile(filePath, "utf8"),
+                fs.stat(filePath),
+            ]);
+            return {
+                fileId: name,
+                name,
+                content,
+                revision: contentRevision(content),
+                modifiedTime: stat.mtime.toISOString(),
+            };
+        }
+        catch (err) {
+            if (isEnoent(err))
+                throw new DriveNotFoundError(name);
+            throw err;
+        }
+    }
+    async createFile(name, content) {
+        this.assertSafePath(name);
+        if (Buffer.byteLength(content, "utf8") > MAX_FILE_SIZE_BYTES) {
+            throw new Error(`File '${name}' exceeds max size of ${MAX_FILE_SIZE_BYTES} bytes`);
+        }
+        const filePath = path.join(this.wikiDir, name);
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        // Guard against accidental overwrite using exclusive write flag
+        try {
+            await fs.writeFile(filePath, content, { encoding: "utf8", flag: "wx" });
+        }
+        catch (err) {
+            if (err.code === "EEXIST") {
+                throw new DrivePermissionError(`File '${name}' already exists. Use update_page instead.`);
+            }
+            throw err;
+        }
+        const stat = await fs.stat(filePath);
+        const result = {
+            fileId: name,
+            revision: contentRevision(content),
+            modifiedTime: stat.mtime.toISOString(),
+        };
+        this.scheduleBackup(name, content);
+        return result;
+    }
+    async updateFile(fileId, content, seenRevision) {
+        // For local storage, fileId === filename
+        const name = fileId;
+        this.assertSafePath(name);
+        if (Buffer.byteLength(content, "utf8") > MAX_FILE_SIZE_BYTES) {
+            throw new Error(`Content exceeds max size of ${MAX_FILE_SIZE_BYTES} bytes`);
+        }
+        const filePath = path.join(this.wikiDir, name);
+        const existing = await fs.readFile(filePath, "utf8").catch((err) => {
+            if (isEnoent(err))
+                throw new DriveNotFoundError(name);
+            throw err;
+        });
+        // Optimistic concurrency: compare content hashes
+        const currentRevision = contentRevision(existing);
+        if (seenRevision && currentRevision !== seenRevision) {
+            throw new DriveConflictError(name, seenRevision, currentRevision);
+        }
+        await fs.writeFile(filePath, content, "utf8");
+        const stat = await fs.stat(filePath);
+        const result = {
+            fileId: name,
+            revision: contentRevision(content),
+            modifiedTime: stat.mtime.toISOString(),
+        };
+        this.scheduleBackup(name, content);
+        return result;
+    }
+    async renameFile(fileId, newName) {
+        const oldName = fileId;
+        this.assertSafePath(oldName);
+        this.assertSafePath(newName);
+        const oldPath = path.join(this.wikiDir, oldName);
+        const newPath = path.join(this.wikiDir, newName);
+        await fs.mkdir(path.dirname(newPath), { recursive: true });
+        try {
+            await fs.rename(oldPath, newPath);
+        }
+        catch (err) {
+            if (isEnoent(err))
+                throw new DriveNotFoundError(oldName);
+            throw err;
+        }
+        const content = await fs.readFile(newPath, "utf8");
+        const stat = await fs.stat(newPath);
+        const result = {
+            fileId: newName,
+            revision: contentRevision(content),
+            modifiedTime: stat.mtime.toISOString(),
+        };
+        this.scheduleBackup(newName, content);
+        return result;
+    }
+    async deleteFile(name) {
+        this.assertSafePath(name);
+        const filePath = path.join(this.wikiDir, name);
+        try {
+            await fs.unlink(filePath);
+        }
+        catch (err) {
+            if (isEnoent(err))
+                throw new DriveNotFoundError(name);
+            throw err;
+        }
+        await this.pruneEmptyParentDirs(name);
+    }
+    async bootstrapWikiFiles() {
+        await fs.mkdir(this.wikiDir, { recursive: true });
+        const today = new Date().toISOString().slice(0, 10);
+        const bootstrapIfMissing = async (filename, initialContent) => {
+            const filePath = path.join(this.wikiDir, filename);
+            try {
+                await fs.writeFile(filePath, initialContent, { encoding: "utf8", flag: "wx" });
+            }
+            catch (err) {
+                if (err.code !== "EEXIST")
+                    throw err;
+            }
+        };
+        await bootstrapIfMissing("index.md", `---\ntitle: Index\nupdated: ${today}\n---\n\n# Wiki Index\n\n| ID | Page | Summary | Updated |\n|---|---|---|---|\n`);
+        await bootstrapIfMissing("log.md", `---\ntitle: Log\nupdated: ${today}\n---\n\n# Wiki Log\n\nAppend-only record of ingests, queries, and lint passes.\n\n`);
+    }
+    // ── Private helpers ────────────────────────────────────────────────────────
+    assertSafePath(name) {
+        normalizeWikiPath(name);
+    }
+    scheduleBackup(name, content) {
+        if (!this.backup)
+            return;
+        this.backup.backup(name, content).catch((err) => {
+            console.warn(`[backup] Failed to back up '${name}' to Drive:`, err);
+        });
+    }
+    async pruneEmptyParentDirs(name) {
+        let relativeDir = path.posix.dirname(name.replace(/\\/g, "/"));
+        while (relativeDir && relativeDir !== ".") {
+            if (!relativeDir.includes("/") && PROTECTED_ROOT_FOLDERS.has(relativeDir)) {
+                break;
+            }
+            const dirPath = path.join(this.wikiDir, relativeDir);
+            let entries;
+            try {
+                entries = await fs.readdir(dirPath);
+            }
+            catch (err) {
+                if (isEnoent(err))
+                    break;
+                throw err;
+            }
+            if (entries.length > 0)
+                break;
+            await fs.rmdir(dirPath).catch((err) => {
+                if (!isEnoent(err))
+                    throw err;
+            });
+            const parent = path.posix.dirname(relativeDir);
+            if (parent === relativeDir)
+                break;
+            relativeDir = parent;
+        }
+    }
+}
+export class SupabaseStorageClient {
+    supabaseUrl;
+    serviceRoleKey;
+    bucket;
+    prefix;
+    cacheLocation;
+    backup;
+    constructor(options) {
+        this.supabaseUrl = options.supabaseUrl.trim().replace(/\/$/, "");
+        this.serviceRoleKey = options.serviceRoleKey.trim();
+        this.bucket = options.bucket.trim();
+        this.prefix = options.prefix?.trim().replace(/^\/+|\/+$/g, "") ?? "";
+        this.cacheLocation = path.resolve(options.cacheLocation ?? path.join(".wiki-cache", "supabase", this.cacheKeySegment()));
+        this.backup = options.backup ?? null;
+    }
+    withPrefix(additionalPrefix) {
+        const scopedPrefix = combinePosixPrefix(this.prefix, additionalPrefix);
+        return new SupabaseStorageClient({
+            supabaseUrl: this.supabaseUrl,
+            serviceRoleKey: this.serviceRoleKey,
+            bucket: this.bucket,
+            prefix: scopedPrefix,
+            cacheLocation: path.join(process.env.WIKI_CACHE_DIR ?? path.join(".wiki-cache", "supabase"), this.sanitizeForCache(scopedPrefix || "root")),
+            backup: this.backup,
+        });
+    }
+    getStorageLocation() {
+        return this.cacheLocation;
+    }
+    async verifyAccess() {
+        if (!this.supabaseUrl || !this.serviceRoleKey || !this.bucket) {
+            throw new DriveAuthError("Supabase storage not configured. Set SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY, and SUPABASE_STORAGE_BUCKET.");
+        }
+        await fs.mkdir(this.cacheLocation, { recursive: true });
+        // Cheap bucket-reachability check: list at most 1 object
+        const objectPrefix = this.prefix ? `${this.prefix}/` : "";
+        const url = `${this.supabaseUrl}/storage/v1/object/list/${encodeURIComponent(this.bucket)}`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: this.authHeaders({ "content-type": "application/json" }),
+            body: JSON.stringify({ prefix: objectPrefix, limit: 1, offset: 0 }),
+        }).catch(() => null);
+        if (!response || !response.ok) {
+            const body = response ? await response.text().catch(() => "") : "network error";
+            throw new DriveAuthError(`Cannot access Supabase storage bucket '${this.bucket}': ${response?.status ?? ""} ${body}`);
+        }
+    }
+    async listFiles() {
+        const rows = [];
+        await this.walkList("", rows);
+        return rows.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /**
+     * HEAD the object rather than downloading it.
+     *
+     * Deliberately conservative: only a 404 is treated as "absent". Any other
+     * non-OK status falls back to a full read, because the sole caller uses this
+     * to detect an externally wiped wiki, and a false negative would trigger an
+     * unnecessary re-bootstrap and index backfill.
+     */
+    async fileExists(name) {
+        const safeName = normalizeWikiPath(name);
+        const encoded = encodePathSegments(this.objectPath(safeName));
+        const url = `${this.supabaseUrl}/storage/v1/object/${this.bucket}/${encoded}`;
+        const response = await fetch(url, { method: "HEAD", headers: this.authHeaders() }).catch(() => null);
+        if (response?.ok)
+            return true;
+        if (response?.status === 404)
+            return false;
+        return this.readFile(safeName).then(() => true).catch((err) => {
+            if (err instanceof DriveNotFoundError)
+                return false;
+            throw err;
+        });
+    }
+    async readFile(name) {
+        const safeName = normalizeWikiPath(name);
+        const objectPath = this.objectPath(safeName);
+        const encoded = encodePathSegments(objectPath);
+        const cacheBust = `${Date.now().toString(36)}-${contentRevision(objectPath).slice(0, 8)}`;
+        const url = `${this.supabaseUrl}/storage/v1/object/${this.bucket}/${encoded}?_cb=${cacheBust}`;
+        const response = await fetch(url, {
+            method: "GET",
+            headers: this.authHeaders({
+                "cache-control": "no-cache, no-store, max-age=0",
+                pragma: "no-cache",
+            }),
+        }).catch(() => null);
+        if (!response || response.status === 404) {
+            throw new DriveNotFoundError(safeName);
+        }
+        if (!response.ok) {
+            // Supabase Storage returns HTTP 400 (not 404) for missing objects;
+            // detect this by checking the JSON body's statusCode field.
+            if (response.status === 400) {
+                const body = await response.json().catch(() => null);
+                if (body?.statusCode === "404") {
+                    throw new DriveNotFoundError(safeName);
+                }
+            }
+            throw new Error(`Supabase read failed for '${safeName}' (${response.status})`);
+        }
+        const content = await response.text();
+        const modifiedTime = this.parseModifiedTime(response.headers.get("last-modified"));
+        return {
+            fileId: safeName,
+            name: safeName,
+            content,
+            revision: contentRevision(content),
+            modifiedTime,
+        };
+    }
+    async createFile(name, content) {
+        const safeName = normalizeWikiPath(name);
+        if (Buffer.byteLength(content, "utf8") > MAX_FILE_SIZE_BYTES) {
+            throw new Error(`File '${safeName}' exceeds max size of ${MAX_FILE_SIZE_BYTES} bytes`);
+        }
+        const existing = await this.readFile(safeName).then(() => true).catch((err) => {
+            if (err instanceof DriveNotFoundError)
+                return false;
+            throw err;
+        });
+        if (existing) {
+            throw new DrivePermissionError(`File '${safeName}' already exists. Use update_page instead.`);
+        }
+        await this.uploadObject(safeName, content, false);
+        const result = {
+            fileId: safeName,
+            revision: contentRevision(content),
+            modifiedTime: new Date().toISOString(),
+        };
+        this.scheduleBackup(safeName, content);
+        return result;
+    }
+    async updateFile(fileId, content, seenRevision) {
+        const safeName = normalizeWikiPath(fileId);
+        if (Buffer.byteLength(content, "utf8") > MAX_FILE_SIZE_BYTES) {
+            throw new Error(`Content exceeds max size of ${MAX_FILE_SIZE_BYTES} bytes`);
+        }
+        // Skip the re-read that the original code used for conflict detection.
+        // Supabase Storage has no server-side CAS so conflict detection is always
+        // application-level; the extra GET here (~1-2 s on hosted Supabase) provided
+        // no stronger guarantee than the caller's own preceding readFile call.
+        // When seenRevision is absent there is nothing to compare against anyway.
+        await this.uploadObject(safeName, content, true);
+        const result = {
+            fileId: safeName,
+            revision: contentRevision(content),
+            modifiedTime: new Date().toISOString(),
+        };
+        this.scheduleBackup(safeName, content);
+        return result;
+    }
+    async renameFile(fileId, newName) {
+        const oldName = normalizeWikiPath(fileId);
+        const nextName = normalizeWikiPath(newName);
+        const existing = await this.readFile(oldName);
+        await this.uploadObject(nextName, existing.content, true);
+        await this.deleteObject(oldName);
+        const result = {
+            fileId: nextName,
+            revision: contentRevision(existing.content),
+            modifiedTime: new Date().toISOString(),
+        };
+        this.scheduleBackup(nextName, existing.content);
+        return result;
+    }
+    async deleteFile(name) {
+        const safeName = normalizeWikiPath(name);
+        await this.deleteObject(safeName);
+        await this.pruneEmptyParentDirs(safeName);
+    }
+    async bootstrapWikiFiles() {
+        const today = new Date().toISOString().slice(0, 10);
+        const bootstrapIfMissing = async (filename, initialContent) => {
+            const exists = await this.readFile(filename).then(() => true).catch((err) => {
+                if (err instanceof DriveNotFoundError)
+                    return false;
+                throw err;
+            });
+            if (!exists) {
+                await this.createFile(filename, initialContent);
+            }
+        };
+        // Seed structural template files from the bundled seed/ directory.
+        // seed/ contains only taxonomy scaffolding — no user-specific content.
+        // Only creates missing files; never overwrites existing content so user
+        // edits are preserved.  Present in the Docker image via `COPY . .`.
+        const seedSourceDir = path.resolve("seed");
+        let seededFromDisk = false;
+        let seedDirExists = false;
+        try {
+            const stat = await fs.stat(seedSourceDir);
+            seedDirExists = stat.isDirectory();
+        }
+        catch {
+            // seed/ not present in this build — fall through to minimal fallback
+        }
+        if (seedDirExists) {
+            let seededCount = 0;
+            const walkDir = async (dir, relBase) => {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    const relPath = relBase ? `${relBase}/${entry.name}` : entry.name;
+                    if (entry.isDirectory()) {
+                        await walkDir(fullPath, relPath);
+                    }
+                    else if (entry.name.endsWith(".md")) {
+                        try {
+                            const content = await fs.readFile(fullPath, "utf8");
+                            const existed = await this.readFile(relPath).then(() => true).catch((err) => {
+                                if (err instanceof DriveNotFoundError)
+                                    return false;
+                                throw err;
+                            });
+                            if (!existed) {
+                                await this.createFile(relPath, content);
+                                seededCount += 1;
+                            }
+                        }
+                        catch (err) {
+                            console.warn(`[bootstrap] Failed to seed '${relPath}':`, err instanceof Error ? err.message : err);
+                        }
+                    }
+                }
+            };
+            try {
+                await walkDir(seedSourceDir, "");
+                seededFromDisk = true;
+                console.log(`[bootstrap] Seeded ${seededCount} file(s) from seed/`);
+            }
+            catch (err) {
+                console.warn("[bootstrap] walkDir error:", err instanceof Error ? err.message : err);
+            }
+        }
+        else {
+            console.log(`[bootstrap] seed/ dir not found, using minimal fallback`);
+        }
+        if (!seededFromDisk) {
+            console.log("[bootstrap] Seeding from disk unavailable; ensuring minimal root files");
+        }
+        // Always ensure root index/log exist, even when seed/ is present.
+        // seed/ currently contains taxonomy scaffolding and may not include root files.
+        await bootstrapIfMissing("index.md", `---\ntitle: Index\nupdated: ${today}\n---\n\n# Wiki Index\n\n| ID | Page | Summary | Updated |\n|---|---|---|---|\n`);
+        await bootstrapIfMissing("log.md", `---\ntitle: Log\nupdated: ${today}\n---\n\n# Wiki Log\n\nAppend-only record of ingests, queries, and lint passes.\n\n`);
+    }
+    authHeaders(extra) {
+        return {
+            apikey: this.serviceRoleKey,
+            authorization: `Bearer ${this.serviceRoleKey}`,
+            ...extra,
+        };
+    }
+    objectPath(name) {
+        return this.prefix ? `${this.prefix}/${name}` : name;
+    }
+    async walkList(relativePrefix, results, depth = 0) {
+        if (depth > 15)
+            return;
+        const items = await this.listObjects(relativePrefix);
+        const subdirPromises = [];
+        for (const item of items) {
+            if (this.isDirectoryItem(item)) {
+                const nextPrefix = relativePrefix ? `${relativePrefix}/${item.name}` : item.name;
+                subdirPromises.push(this.walkList(nextPrefix, results, depth + 1));
+            }
+            else {
+                const relName = relativePrefix ? `${relativePrefix}/${item.name}` : item.name;
+                if (relName.endsWith(".md")) {
+                    results.push({
+                        fileId: relName,
+                        name: relName,
+                        modifiedTime: item.updated_at ?? item.created_at ?? new Date().toISOString(),
+                        size: Number(item.metadata?.size ?? 0),
+                    });
+                }
+            }
+        }
+        await Promise.all(subdirPromises);
+    }
+    async listObjects(relativePrefix) {
+        const objectPrefix = combinePosixPrefix(this.prefix, relativePrefix);
+        const url = `${this.supabaseUrl}/storage/v1/object/list/${encodeURIComponent(this.bucket)}`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: this.authHeaders({ "content-type": "application/json" }),
+            body: JSON.stringify({
+                prefix: objectPrefix,
+                limit: 1000,
+                offset: 0,
+            }),
+        }).catch(() => null);
+        if (!response) {
+            throw new Error("Supabase list request failed");
+        }
+        if (!response.ok) {
+            const body = await response.text().catch(() => "");
+            throw new Error(`Supabase list failed (${response.status}): ${body}`);
+        }
+        const payload = (await response.json().catch(() => []));
+        return Array.isArray(payload) ? payload : [];
+    }
+    async uploadObject(name, content, upsert) {
+        const objectPath = this.objectPath(name);
+        const url = `${this.supabaseUrl}/storage/v1/object/${this.bucket}/${encodePathSegments(objectPath)}`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: this.authHeaders({
+                "content-type": "text/markdown; charset=utf-8",
+                "cache-control": "no-store, max-age=0",
+                "x-upsert": upsert ? "true" : "false",
+            }),
+            body: content,
+        }).catch(() => null);
+        if (!response) {
+            throw new Error(`Supabase upload failed for '${name}'`);
+        }
+        if (!response.ok) {
+            if (!upsert && response.status === 409) {
+                throw new DrivePermissionError(`File '${name}' already exists. Use update_page instead.`);
+            }
+            const body = await response.text().catch(() => "");
+            throw new Error(`Supabase upload failed for '${name}' (${response.status}): ${body}`);
+        }
+    }
+    async deleteObject(name) {
+        const objectPath = this.objectPath(name);
+        const url = `${this.supabaseUrl}/storage/v1/object/${this.bucket}/${encodePathSegments(objectPath)}`;
+        const response = await fetch(url, {
+            method: "DELETE",
+            headers: this.authHeaders(),
+        }).catch(() => null);
+        if (!response || (!response.ok && response.status !== 404)) {
+            const body = await response?.text().catch(() => "");
+            throw new Error(`Supabase delete failed for '${name}'${body ? `: ${body}` : ""}`);
+        }
+    }
+    async pruneEmptyParentDirs(name) {
+        let relativeDir = path.posix.dirname(name);
+        while (relativeDir && relativeDir !== ".") {
+            if (!relativeDir.includes("/") && PROTECTED_ROOT_FOLDERS.has(relativeDir)) {
+                break;
+            }
+            const items = await this.listObjects(relativeDir).catch(() => []);
+            if (items.length > 0)
+                break;
+            const markerCandidates = [relativeDir, `${relativeDir}/`];
+            for (const marker of markerCandidates) {
+                await this.deleteObject(marker).catch(() => { });
+            }
+            const parent = path.posix.dirname(relativeDir);
+            if (parent === relativeDir)
+                break;
+            relativeDir = parent;
+        }
+    }
+    isDirectoryItem(item) {
+        return !item.id && !item.metadata;
+    }
+    parseModifiedTime(value) {
+        if (!value)
+            return new Date().toISOString();
+        const parsed = new Date(value);
+        if (Number.isNaN(parsed.getTime()))
+            return new Date().toISOString();
+        return parsed.toISOString();
+    }
+    cacheKeySegment() {
+        return this.sanitizeForCache(`${this.bucket}-${this.prefix || "root"}`);
+    }
+    sanitizeForCache(value) {
+        return value.replace(/[^a-z0-9._-]/gi, "_");
+    }
+    scheduleBackup(name, content) {
+        if (!this.backup)
+            return;
+        this.backup.backup(name, content).catch((err) => {
+            console.warn(`[backup] Failed to back up '${name}' to Drive:`, err);
+        });
+    }
+}
+// ─── Singleton factory ────────────────────────────────────────────────────────
+let _client = null;
+async function getOptionalDriveBackup() {
+    if (process.env.DRIVE_BACKUP_ENABLED !== "true")
+        return null;
+    try {
+        const { DriveBackup } = await import("../backup/drive.js");
+        return DriveBackup.tryCreate();
+    }
+    catch (err) {
+        // Drive backup not available or not configured — continue without it
+        console.warn("[backup] DriveBackup unavailable:", err instanceof Error ? err.message : String(err));
+        return null;
+    }
+}
+export async function getLocalClient() {
+    if (_client && _client instanceof LocalClient) {
+        return _client;
+    }
+    const wikiDir = process.env.WIKI_DIR ?? "./wiki";
+    const backup = await getOptionalDriveBackup();
+    const local = new LocalClient(wikiDir, backup);
+    _client = local;
+    return local;
+}
+export async function getStorageClient() {
+    if (_client)
+        return _client;
+    const backend = (process.env.STORAGE_BACKEND ?? "local").trim().toLowerCase();
+    if (backend === "supabase") {
+        const supabaseUrl = process.env.SUPABASE_URL ?? "";
+        const serviceRoleKey = process.env.SUPABASE_SERVICE_ROLE_KEY ?? "";
+        const bucket = process.env.SUPABASE_STORAGE_BUCKET ?? "brains-wiki";
+        const prefix = process.env.SUPABASE_STORAGE_PREFIX ?? "";
+        const cacheRoot = process.env.WIKI_CACHE_DIR ?? path.join(".wiki-cache", "supabase");
+        const backup = await getOptionalDriveBackup();
+        _client = new SupabaseStorageClient({
+            supabaseUrl,
+            serviceRoleKey,
+            bucket,
+            prefix,
+            cacheLocation: path.join(cacheRoot, "root"),
+            backup,
+        });
+        return _client;
+    }
+    return getLocalClient();
+}
+export function createScopedStorageClient(baseClient, scopePrefix) {
+    if (!scopePrefix)
+        return baseClient;
+    if (baseClient instanceof LocalClient) {
+        const scopedRoot = path.join(baseClient.getStorageLocation(), scopePrefix);
+        return new LocalClient(scopedRoot);
+    }
+    if (baseClient instanceof SupabaseStorageClient) {
+        return baseClient.withPrefix(scopePrefix);
+    }
+    return baseClient;
+}
+function pathUnderPrefix(name, prefix) {
+    return name === prefix || name.startsWith(`${prefix}/`);
+}
+export class GrantAwareStorageClient {
+    ownClient;
+    grants;
+    ownSubject;
+    constructor(ownClient, grants, ownSubject) {
+        this.ownClient = ownClient;
+        this.grants = grants;
+        this.ownSubject = ownSubject;
+    }
+    resolve(name) {
+        const grant = this.grants.find((g) => pathUnderPrefix(name, g.prefix));
+        return grant ? grant.client : this.ownClient;
+    }
+    /**
+     * The true storage-owner subject for `name` — the grant owner's subject if
+     * the path falls under an active grant, otherwise the requester's own
+     * subject. Search-index writes must attribute to this, not the raw
+     * authenticated actor, or an owner never sees a grantee's contributions
+     * via list_pages/search_pages (BRA-381).
+     */
+    resolveOwnerSubject(name) {
+        const grant = this.grants.find((g) => pathUnderPrefix(name, g.prefix));
+        return grant ? grant.ownerSubject : this.ownSubject;
+    }
+    getStorageLocation() {
+        return this.ownClient.getStorageLocation();
+    }
+    async verifyAccess() {
+        await this.ownClient.verifyAccess();
+    }
+    async bootstrapWikiFiles() {
+        await this.ownClient.bootstrapWikiFiles();
+    }
+    fileExists(name) {
+        return this.resolve(name).fileExists(name);
+    }
+    async listFiles() {
+        const own = await this.listOwnFiles();
+        const merged = [...own];
+        const seen = new Set(own.map((f) => f.name));
+        const grantedFileLists = await Promise.all(this.grants.map((g) => g.client.listFiles()));
+        grantedFileLists.forEach((files, i) => {
+            const prefix = this.grants[i].prefix;
+            for (const f of files) {
+                // Defence in depth: only surface files actually inside the granted
+                // project — the owner's scoped client's root is their whole wiki.
+                if (!pathUnderPrefix(f.name, prefix) || seen.has(f.name))
+                    continue;
+                seen.add(f.name);
+                merged.push(f);
+            }
+        });
+        return merged.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /**
+     * Own-namespace files only, excluding anything merged in from grants.
+     * audit_index compares this listing against `listAllPageNames(userId)`,
+     * which likewise only returns the actor's own index rows — the merged
+     * `listFiles()` would put grant-owner files on the Drive side with no
+     * counterpart on the index side, fabricating "unindexed" drift for shared
+     * pages the actor never actually owns (BRA-1857 / GH #453).
+     */
+    listOwnFiles() {
+        return this.ownClient.listFiles();
+    }
+    readFile(name) {
+        return this.resolve(name).readFile(name);
+    }
+    createFile(name, content) {
+        return this.resolve(name).createFile(name, content);
+    }
+    updateFile(fileId, content, seenRevision) {
+        return this.resolve(fileId).updateFile(fileId, content, seenRevision);
+    }
+    async renameFile(fileId, newName) {
+        const fromClient = this.resolve(fileId);
+        const toClient = this.resolve(newName);
+        if (fromClient !== toClient) {
+            throw new DrivePermissionError(`Cannot rename '${fileId}' to '${newName}': crosses a project-share boundary.`);
+        }
+        return fromClient.renameFile(fileId, newName);
+    }
+    deleteFile(name) {
+        return this.resolve(name).deleteFile(name);
+    }
+}
+/**
+ * Resolves the correct subject to attribute a Postgres search-index write to
+ * for `name`: the grant owner's subject when `drive` is grant-aware and
+ * `name` falls under an active grant, otherwise `actorUserId` unchanged.
+ * Use this — not the raw authenticated actor — for every index call
+ * (upsertPage, deletePage, fetchPageRow, syncPageLinks, etc.) so an owner can
+ * see a grantee's contributions via list_pages/search_pages (BRA-381).
+ */
+export function resolveIndexOwnerSubject(drive, name, actorUserId) {
+    if (drive instanceof GrantAwareStorageClient)
+        return drive.resolveOwnerSubject(name);
+    return actorUserId;
+}
+//# sourceMappingURL=client.js.map