nebula-cms 0.1.3 → 0.1.5

package/dist/client/js/storage/github.js

@@ -0,0 +1,216 @@
+/*
+ * Storage adapter backed by the GitHub REST API.
+ * Uses a Personal Access Token for authentication. All file operations
+ * target src/content/{collection}/ within the repository.
+ */
+/**
+ * Encodes a Uint8Array to a base64 string without using deprecated unescape().
+ * @param {Uint8Array} bytes - The bytes to encode
+ * @return {string} Base64-encoded string
+ */
+function uint8ToBase64(bytes) {
+    let binary = '';
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+}
+export class GitHubAdapter {
+    token;
+    owner;
+    repo;
+    // Cached on validate(); defaults to 'main' before validation
+    defaultBranch = 'main';
+    /**
+     * @param {string} token - GitHub Personal Access Token
+     * @param {string} repoSlug - Repository in "owner/repo" format
+     */
+    constructor(token, repoSlug) {
+        this.token = token;
+        const [owner, repo] = repoSlug.split('/');
+        this.owner = owner;
+        this.repo = repo;
+    }
+    /**
+     * Validates credentials by fetching repo metadata and caches the default branch.
+     * @return {Promise<void>}
+     */
+    async validate() {
+        const res = await this.request('GET', `/repos/${this.owner}/${this.repo}`);
+        if (!res.ok) {
+            const status = res.status;
+            if (status === 401)
+                throw new Error('Invalid or expired token');
+            if (status === 403)
+                throw new Error('Token lacks repository access');
+            if (status === 404)
+                throw new Error(`Repository "${this.owner}/${this.repo}" not found`);
+            throw new Error(`GitHub API error: ${status}`);
+        }
+        const data = await res.json();
+        this.defaultBranch = data.default_branch;
+    }
+    /**
+     * Lists files in a collection matching the given extensions, with their raw content.
+     * @param {string} collection - The collection name
+     * @param {string[]} extensions - File extensions to include (e.g. ['.md', '.mdx'])
+     * @return {Promise<FileEntry[]>} Array of filename + content pairs
+     */
+    async listFiles(collection, extensions) {
+        const path = `src/content/${collection}`;
+        // Get directory listing
+        const listRes = await this.request('GET', `/repos/${this.owner}/${this.repo}/contents/${path}?ref=${this.defaultBranch}`);
+        if (!listRes.ok) {
+            if (listRes.status === 404)
+                return [];
+            throw new Error(`Failed to list files: ${listRes.status}`);
+        }
+        const listing = await listRes.json();
+        // Filter to requested extensions and fetch all files in parallel
+        const filtered = listing.filter((f) => extensions.some((ext) => f.name.endsWith(ext)));
+        return Promise.all(filtered.map(async (file) => ({
+            filename: file.name,
+            content: await this.readFile(collection, file.name),
+        })));
+    }
+    /**
+     * Deletes a file from the repository via the Contents API.
+     * @param {string} collection - The collection name
+     * @param {string} filename - The filename to delete
+     * @return {Promise<void>}
+     */
+    async deleteFile(collection, filename) {
+        const path = `src/content/${collection}/${filename}`;
+        // Get the current SHA (required by the GitHub Contents API for deletion)
+        const existing = await this.request('GET', `/repos/${this.owner}/${this.repo}/contents/${path}?ref=${this.defaultBranch}`);
+        if (!existing.ok)
+            throw new Error(`File not found for deletion: ${path}`);
+        const data = await existing.json();
+        const res = await this.request('DELETE', `/repos/${this.owner}/${this.repo}/contents/${path}`, undefined, {
+            message: `Delete ${path}`,
+            sha: data.sha,
+            branch: this.defaultBranch,
+        });
+        if (!res.ok)
+            throw new Error(`Failed to delete ${path}: ${res.status}`);
+    }
+    /**
+     * Reads a single file's raw content via the raw+json Accept header.
+     * @param {string} collection - The collection name
+     * @param {string} filename - The filename
+     * @return {Promise<string>} The file content
+     */
+    async readFile(collection, filename) {
+        const path = `src/content/${collection}/${filename}`;
+        const res = await this.request('GET', `/repos/${this.owner}/${this.repo}/contents/${path}?ref=${this.defaultBranch}`, { Accept: 'application/vnd.github.raw+json' });
+        if (!res.ok) {
+            throw new Error(`Failed to read ${path}: ${res.status}`);
+        }
+        return res.text();
+    }
+    /**
+     * Writes a single file via the Contents API. Fetches the current SHA for updates.
+     * @param {string} collection - The collection name
+     * @param {string} filename - The filename
+     * @param {string} content - The content to write
+     * @return {Promise<void>}
+     */
+    async writeFile(collection, filename, content) {
+        const path = `src/content/${collection}/${filename}`;
+        // Get current SHA if file exists (required by GitHub API for updates)
+        let sha;
+        const existing = await this.request('GET', `/repos/${this.owner}/${this.repo}/contents/${path}?ref=${this.defaultBranch}`);
+        if (existing.ok) {
+            const data = await existing.json();
+            sha = data.sha;
+        }
+        const body = {
+            message: `Update ${path}`,
+            content: uint8ToBase64(new TextEncoder().encode(content)),
+            branch: this.defaultBranch,
+        };
+        if (sha)
+            body.sha = sha;
+        const res = await this.request('PUT', `/repos/${this.owner}/${this.repo}/contents/${path}`, undefined, body);
+        if (!res.ok) {
+            const errText = await res.text();
+            throw new Error(`Failed to write ${path}: ${res.status} ${errText}`);
+        }
+    }
+    /**
+     * Writes multiple files in a single atomic commit using the Git Trees + Commits API.
+     * @param {FileWrite[]} files - Array of files to write
+     * @return {Promise<void>}
+     */
+    async writeFiles(files) {
+        if (files.length === 0)
+            return;
+        if (files.length === 1) {
+            await this.writeFile(files[0].collection, files[0].filename, files[0].content);
+            return;
+        }
+        // 1. Get current commit SHA for the default branch
+        const refRes = await this.request('GET', `/repos/${this.owner}/${this.repo}/git/ref/heads/${this.defaultBranch}`);
+        if (!refRes.ok)
+            throw new Error(`Failed to get branch ref: ${refRes.status}`);
+        const refData = await refRes.json();
+        const baseCommitSHA = refData.object.sha;
+        // Get the base tree SHA from the current commit
+        const commitRes = await this.request('GET', `/repos/${this.owner}/${this.repo}/git/commits/${baseCommitSHA}`);
+        if (!commitRes.ok)
+            throw new Error(`Failed to get commit: ${commitRes.status}`);
+        const commitData = await commitRes.json();
+        const baseTreeSHA = commitData.tree.sha;
+        // 2. Create a new tree containing all file changes
+        const tree = files.map((f) => ({
+            path: `src/content/${f.collection}/${f.filename}`,
+            mode: '100644',
+            type: 'blob',
+            content: f.content,
+        }));
+        const treeRes = await this.request('POST', `/repos/${this.owner}/${this.repo}/git/trees`, undefined, { base_tree: baseTreeSHA, tree });
+        if (!treeRes.ok)
+            throw new Error(`Failed to create tree: ${treeRes.status}`);
+        const treeData = await treeRes.json();
+        // 3. Create a new commit pointing at the new tree
+        const paths = files.map((f) => `${f.collection}/${f.filename}`).join(', ');
+        const newCommitRes = await this.request('POST', `/repos/${this.owner}/${this.repo}/git/commits`, undefined, {
+            message: `Update ${paths}`,
+            tree: treeData.sha,
+            parents: [baseCommitSHA],
+        });
+        if (!newCommitRes.ok)
+            throw new Error(`Failed to create commit: ${newCommitRes.status}`);
+        const newCommitData = await newCommitRes.json();
+        // 4. Advance the branch ref to the new commit
+        const updateRefRes = await this.request('PATCH', `/repos/${this.owner}/${this.repo}/git/refs/heads/${this.defaultBranch}`, undefined, { sha: newCommitData.sha });
+        if (!updateRefRes.ok)
+            throw new Error(`Failed to update ref: ${updateRefRes.status}`);
+    }
+    /**
+     * Makes an authenticated request to the GitHub API.
+     * @param {string} method - HTTP method
+     * @param {string} path - API path (appended to https://api.github.com)
+     * @param {Record<string, string>} [extraHeaders] - Additional headers to merge
+     * @param {unknown} [body] - JSON body to send
+     * @return {Promise<Response>} The fetch response
+     */
+    async request(method, path, extraHeaders, body) {
+        const headers = {
+            Authorization: `Bearer ${this.token}`,
+            'X-GitHub-Api-Version': '2026-03-10',
+            // Default to JSON so the browser cache distinguishes from raw content requests
+            Accept: 'application/vnd.github+json',
+            ...extraHeaders,
+        };
+        if (body) {
+            headers['Content-Type'] = 'application/json';
+        }
+        return fetch(`https://api.github.com${path}`, {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+            // API responses must never be served from browser cache
+            cache: 'no-store',
+        });
+    }
+}

package/dist/client/js/storage/storage.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Backend configuration stored in IndexedDB. Tagged union discriminated on `type`.
+ * Security note: the GitHub token is stored in plaintext in IndexedDB. This is a
+ * deliberate trade-off for a client-only app with no server to proxy through.
+ * Same-origin policy protects it from other sites, but any XSS vulnerability
+ * would expose the token.
+ */
+export type BackendConfig = {
+    type: 'fsa';
+    handle: FileSystemDirectoryHandle;
+} | {
+    type: 'github';
+    token: string;
+    repo: string;
+};
+/**
+ * Stores backend configuration in IndexedDB for persistence across sessions.
+ * @param {BackendConfig} config - The backend config to store
+ * @return {Promise<void>}
+ */
+export declare function saveBackend(config: BackendConfig): Promise<void>;
+/**
+ * Retrieves stored backend configuration from IndexedDB. Handles migration from the old format where a bare FileSystemDirectoryHandle was stored.
+ * @return {Promise<BackendConfig | null>} The stored config, or null if none exists
+ */
+export declare function loadBackend(): Promise<BackendConfig | null>;
+/**
+ * Removes the stored backend configuration from IndexedDB. Also clears the legacy key if present.
+ * @return {Promise<void>}
+ */
+export declare function clearBackend(): Promise<void>;
+//# sourceMappingURL=storage.d.ts.map

package/dist/client/js/storage/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../../src/client/js/storage/storage.ts"],"names":[],"mappings":"AAUA;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,yBAAyB,CAAA;CAAE,GAClD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAQtE;AAED;;;GAGG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAyBjE;AAED;;;GAGG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAWlD"}

package/dist/client/js/storage/storage.js

@@ -0,0 +1,68 @@
+/*
+ * Backend configuration persistence using IndexedDB.
+ * Stores and retrieves the active storage backend (FSA or GitHub).
+ */
+import { openDB } from './db';
+// Fixed key for the backend config
+const BACKEND_KEY = 'backend';
+/**
+ * Stores backend configuration in IndexedDB for persistence across sessions.
+ * @param {BackendConfig} config - The backend config to store
+ * @return {Promise<void>}
+ */
+export async function saveBackend(config) {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+        const tx = db.transaction('handles', 'readwrite');
+        tx.objectStore('handles').put(config, BACKEND_KEY);
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+    });
+}
+/**
+ * Retrieves stored backend configuration from IndexedDB. Handles migration from the old format where a bare FileSystemDirectoryHandle was stored.
+ * @return {Promise<BackendConfig | null>} The stored config, or null if none exists
+ */
+export async function loadBackend() {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+        const tx = db.transaction('handles', 'readonly');
+        const request = tx.objectStore('handles').get(BACKEND_KEY);
+        request.onsuccess = () => {
+            const result = request.result;
+            if (!result) {
+                // Check for old-format handle stored under the legacy key
+                const legacyRequest = tx.objectStore('handles').get('projectRoot');
+                legacyRequest.onsuccess = () => {
+                    const legacy = legacyRequest.result;
+                    if (legacy && legacy instanceof FileSystemDirectoryHandle) {
+                        resolve({ type: 'fsa', handle: legacy });
+                    }
+                    else {
+                        resolve(null);
+                    }
+                };
+                legacyRequest.onerror = () => resolve(null);
+                return;
+            }
+            resolve(result);
+        };
+        request.onerror = () => reject(request.error);
+    });
+}
+/**
+ * Removes the stored backend configuration from IndexedDB. Also clears the legacy key if present.
+ * @return {Promise<void>}
+ */
+export async function clearBackend() {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+        const tx = db.transaction('handles', 'readwrite');
+        const store = tx.objectStore('handles');
+        store.delete(BACKEND_KEY);
+        // Clean up legacy key if present
+        store.delete('projectRoot');
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+    });
+}

package/dist/client/js/storage/workers/frontmatter.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/client/js/storage/workers/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../../../../../src/client/js/storage/workers/frontmatter.ts"],"names":[],"mappings":""}

package/dist/client/js/storage/workers/frontmatter.js

@@ -0,0 +1,253 @@
+/*
+ * Orchestrator Worker
+ *
+ * Routes file parsing by category: frontmatter files have their YAML block
+ * extracted via string manipulation and sent to the YAML parser worker;
+ * JSON data files are parsed inline; YAML/TOML data files are sent to their
+ * respective parser workers. Parser workers are lazily spawned on first need.
+ */
+import { StorageClient } from '../client';
+import { getFileCategory, getDataFormat } from '../../utils/file-types';
+import { splitFrontmatter } from '../../utils/frontmatter';
+/**
+ * Extracts the raw YAML block from a frontmatter-delimited file (markdown/MDX/Markdoc).
+ * Delegates BOM stripping, CRLF normalization, and delimiter logic to splitFrontmatter.
+ * Returns the raw YAML string without parsing it — parsing is delegated to the YAML parser worker.
+ * @param {string} content - Raw file content
+ * @return {string | null} The raw YAML string between --- delimiters, or null if none found
+ */
+function extractYamlBlock(content) {
+    const { rawFrontmatter } = splitFrontmatter(content);
+    return rawFrontmatter.trim() ? rawFrontmatter : null;
+}
+/*
+//////////////////////////////
+// Parser worker management
+//////////////////////////////
+*/
+// Lazily-spawned parser workers
+let yamlWorker = null;
+let tomlWorker = null;
+// Incrementing ID for correlating batch requests with responses
+let batchIdCounter = 0;
+// Pending batch response promises keyed by ID
+const pendingBatches = new Map();
+/**
+ * Returns the lazily-spawned YAML parser worker, creating it on first call.
+ * Uses `.js` extension in the URL because svelte-package doesn't rewrite URL strings.
+ * @return {Worker} The YAML parser worker instance
+ */
+function getYamlWorker() {
+    if (!yamlWorker) {
+        yamlWorker = new Worker(new URL('./yaml-parser.js', import.meta.url), {
+            type: 'module',
+        });
+        yamlWorker.onmessage = handleParserResponse;
+        yamlWorker.onerror = handleWorkerError;
+    }
+    return yamlWorker;
+}
+/**
+ * Returns the lazily-spawned TOML parser worker, creating it on first call.
+ * Uses `.js` extension in the URL because svelte-package doesn't rewrite URL strings.
+ * @return {Worker} The TOML parser worker instance
+ */
+function getTomlWorker() {
+    if (!tomlWorker) {
+        tomlWorker = new Worker(new URL('./toml-parser.js', import.meta.url), {
+            type: 'module',
+        });
+        tomlWorker.onmessage = handleParserResponse;
+        tomlWorker.onerror = handleWorkerError;
+    }
+    return tomlWorker;
+}
+/**
+ * Handles fatal errors from parser workers by rejecting all pending batch promises
+ * so callers don't hang indefinitely waiting for a response that will never arrive.
+ * @param {ErrorEvent} e - The error event from the worker
+ * @return {void}
+ */
+function handleWorkerError(e) {
+    for (const [id, { reject }] of pendingBatches) {
+        reject(new Error(`Parser worker error: ${e.message}`));
+        pendingBatches.delete(id);
+    }
+}
+/**
+ * Handles responses from parser workers by resolving/rejecting the corresponding
+ * pending batch promise based on the response ID.
+ * @param {MessageEvent} event - The message event from the parser worker
+ * @return {void}
+ */
+function handleParserResponse(event) {
+    const { type, id, ok, results, error } = event.data;
+    // Ignore messages that aren't batch results (e.g. single parse results, stringify results)
+    if (type !== 'parse-batch-result')
+        return;
+    const pending = pendingBatches.get(id);
+    if (!pending)
+        return;
+    pendingBatches.delete(id);
+    if (ok) {
+        pending.resolve(results);
+    }
+    else {
+        pending.reject(new Error(error));
+    }
+}
+/**
+ * Sends a batch of key/content pairs to a parser worker and returns a promise
+ * that resolves with the parsed results map. Uses an incrementing ID for
+ * request/response correlation, following the same pattern as StorageClient.
+ * @param {Worker} worker - The parser worker to send the batch to
+ * @param {BatchItem[]} items - Array of key/content pairs to parse
+ * @return {Promise<Record<string, Record<string, unknown>>>} Map of key to parsed data
+ */
+function sendBatch(worker, items) {
+    const id = String(++batchIdCounter);
+    return new Promise((resolve, reject) => {
+        pendingBatches.set(id, { resolve, reject });
+        worker.postMessage({ type: 'parse-batch', id, items });
+    });
+}
+/*
+//////////////////////////////
+// File categorization and parsing
+//////////////////////////////
+*/
+/**
+ * Processes a list of files by categorizing each file, collecting batch items
+ * for YAML/TOML parser workers, parsing JSON inline, and assembling the final
+ * items array with parsed data.
+ * @param {FileEntry[]} files - The files returned by the storage adapter
+ * @return {Promise<Array<{ filename: string; data: Record<string, unknown> }>>} Parsed items
+ */
+async function processFiles(files) {
+    // Inline-parsed results (JSON files)
+    const inlineResults = [];
+    // Batch items for YAML worker (frontmatter YAML blocks + YAML data files)
+    const yamlBatch = [];
+    // Batch items for TOML worker
+    const tomlBatch = [];
+    // Files with no frontmatter get empty data
+    const emptyDataFiles = [];
+    for (const file of files) {
+        const category = getFileCategory(file.filename);
+        if (category === 'frontmatter') {
+            const yamlBlock = extractYamlBlock(file.content);
+            if (yamlBlock) {
+                yamlBatch.push({ key: file.filename, content: yamlBlock });
+            }
+            else {
+                // No frontmatter found — include with empty data
+                emptyDataFiles.push(file.filename);
+            }
+            continue;
+        }
+        if (category === 'data') {
+            const format = getDataFormat(file.filename);
+            if (format === 'json') {
+                try {
+                    const data = JSON.parse(file.content);
+                    inlineResults.push({ filename: file.filename, data });
+                }
+                catch {
+                    // Invalid JSON — include with empty data
+                    inlineResults.push({ filename: file.filename, data: {} });
+                }
+                continue;
+            }
+            if (format === 'yaml') {
+                yamlBatch.push({ key: file.filename, content: file.content });
+                continue;
+            }
+            if (format === 'toml') {
+                tomlBatch.push({ key: file.filename, content: file.content });
+                continue;
+            }
+        }
+        // Unrecognised file type — include with empty data
+        emptyDataFiles.push(file.filename);
+    }
+    // Send batches to parser workers in parallel
+    const promises = [];
+    let yamlPromiseIdx = -1;
+    let tomlPromiseIdx = -1;
+    if (yamlBatch.length > 0) {
+        yamlPromiseIdx = promises.length;
+        promises.push(sendBatch(getYamlWorker(), yamlBatch));
+    }
+    if (tomlBatch.length > 0) {
+        tomlPromiseIdx = promises.length;
+        promises.push(sendBatch(getTomlWorker(), tomlBatch));
+    }
+    const batchResults = await Promise.all(promises);
+    // Assemble final items from all sources
+    const items = [];
+    // Add inline results (JSON)
+    items.push(...inlineResults);
+    // Add YAML results — filenames are derived from the batch result keys
+    if (yamlPromiseIdx >= 0) {
+        const yamlResults = batchResults[yamlPromiseIdx];
+        for (const [filename, data] of Object.entries(yamlResults)) {
+            items.push({ filename, data });
+        }
+    }
+    // Add TOML results — filenames are derived from the batch result keys
+    if (tomlPromiseIdx >= 0) {
+        const tomlResults = batchResults[tomlPromiseIdx];
+        for (const [filename, data] of Object.entries(tomlResults)) {
+            items.push({ filename, data });
+        }
+    }
+    // Add empty-data files
+    for (const filename of emptyDataFiles) {
+        items.push({ filename, data: {} });
+    }
+    return items;
+}
+/*
+//////////////////////////////
+// Main message handler
+//////////////////////////////
+*/
+// Storage client, initialized when the main thread transfers a port
+let storageClient = null;
+// Handle messages from main thread
+self.addEventListener('message', async (event) => {
+    const { type } = event.data;
+    if (type === 'port') {
+        // Main thread is transferring a MessagePort connected to the storage SharedWorker
+        const port = event.ports[0];
+        storageClient = new StorageClient(port);
+        return;
+    }
+    if (type === 'parse') {
+        const { collection } = event.data;
+        if (!storageClient) {
+            self.postMessage({
+                type: 'error',
+                message: 'Storage port not initialized',
+            });
+            return;
+        }
+        try {
+            // Pass extensions from the message, defaulting to markdown for backward compatibility
+            const extensions = event.data.extensions ?? ['.md', '.mdx'];
+            const files = await storageClient.listFiles(collection, extensions);
+            const items = await processFiles(files);
+            // Sort alphabetically by title, falling back to filename
+            items.sort((a, b) => {
+                const aTitle = typeof a.data.title === 'string' ? a.data.title : a.filename;
+                const bTitle = typeof b.data.title === 'string' ? b.data.title : b.filename;
+                return aTitle.toLowerCase().localeCompare(bTitle.toLowerCase());
+            });
+            self.postMessage({ type: 'result', collection, items });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            self.postMessage({ type: 'error', message });
+        }
+    }
+});

package/dist/client/js/storage/workers/storage.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=storage.d.ts.map

package/dist/client/js/storage/workers/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../../../src/client/js/storage/workers/storage.ts"],"names":[],"mappings":""}