@serve.zone/gitops 2.13.1

package/dist_ts/classes/jobrunners/autobookstackdocs.runner.js

@@ -0,0 +1,361 @@
+import * as plugins from '../../plugins.js';
+import { logger } from '../../logging.js';
+import { BaseJobRunner } from './base.jobrunner.js';
+const KEYCHAIN_PREFIX = 'keychain:';
+const BATCH_SIZE = 5;
+const BATCH_DELAY_MS = 200;
+const HASH_STORAGE_PREFIX = '/job-hashes/';
+/** Simple SHA-256 hex hash */
+async function sha256(content) {
+    const data = new TextEncoder().encode(content);
+    const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+    return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+/**
+ * If the first line of markdown is a heading matching the book name (e.g. "# @org/repo"),
+ * strip it — the book title already provides that context.
+ */
+const REDUNDANT_HEADINGS = ['changelog'];
+function stripRedundantHeading(markdown, bookName) {
+    const firstNewline = markdown.indexOf('\n');
+    const firstLine = (firstNewline === -1 ? markdown : markdown.slice(0, firstNewline)).trim();
+    if (firstLine.startsWith('# ')) {
+        const heading = firstLine.slice(2).trim().toLowerCase();
+        const fullName = bookName.toLowerCase();
+        const repoName = bookName.split('/').pop()?.toLowerCase() || '';
+        // Strip headings matching the book/repo name (with optional trailing decorations)
+        if (heading === fullName || heading === repoName
+            || heading.startsWith(fullName + ' ') || heading.startsWith(repoName + ' ')) {
+            return firstNewline === -1 ? '' : markdown.slice(firstNewline + 1);
+        }
+        // Strip generic redundant headings (e.g. "# Changelog")
+        if (REDUNDANT_HEADINGS.includes(heading)) {
+            return firstNewline === -1 ? '' : markdown.slice(firstNewline + 1);
+        }
+    }
+    return markdown;
+}
+/**
+ * Mapping:
+ *   Git org/group  →  BookStack Shelf
+ *   Git repository →  BookStack Book (named @group/repo, assigned to shelf)
+ *   readme.md      →  BookStack Page (named "readme.md for @group/repo")
+ *   docs/*.md      →  BookStack Pages (named "docs/file.md for @group/repo")
+ *
+ * Content hashes are persisted in storage to skip updates when content hasn't changed.
+ */
+export class AutoBookstackDocsRunner extends BaseJobRunner {
+    jobType = 'autobookstackdocs';
+    async execute(context) {
+        const config = context.jobConfig.autoBookstackDocsConfig;
+        if (!config) {
+            throw new Error('Missing autoBookstackDocsConfig');
+        }
+        // 1. Resolve BookStack token from keychain
+        let tokenSecret = config.bookstackTarget.tokenSecret;
+        if (tokenSecret.startsWith(KEYCHAIN_PREFIX)) {
+            const keychainId = tokenSecret.slice(KEYCHAIN_PREFIX.length);
+            const resolved = await context.smartSecret.getSecret(keychainId);
+            if (!resolved) {
+                throw new Error('Could not retrieve BookStack token from keychain');
+            }
+            tokenSecret = resolved;
+        }
+        // 2. Connect to BookStack
+        const bookstack = new plugins.bookstackClient.BookStackAccount(config.bookstackTarget.baseUrl, config.bookstackTarget.tokenId, tokenSecret);
+        await bookstack.testConnection();
+        logger.jobLog('info', `Connected to BookStack at ${config.bookstackTarget.baseUrl}`, 'bookstack');
+        // 3. Load persisted content hashes (for diff-based updates)
+        const hashKey = `${HASH_STORAGE_PREFIX}${context.jobConfig.id}.json`;
+        const oldHashes = (await context.storageManager.getJSON(hashKey)) || {};
+        const newHashes = {};
+        // 4. Pre-load existing shelves for find-or-create
+        const existingShelves = await bookstack.getShelves();
+        const shelfMap = new Map();
+        for (const shelf of existingShelves) {
+            shelfMap.set(shelf.name.toLowerCase(), shelf);
+        }
+        // Track desired state for deletion reconciliation
+        const syncedShelfNames = new Set();
+        const syncedBookNames = new Map();
+        const shelfBookIds = new Map();
+        let pagesCreated = 0;
+        let pagesUpdated = 0;
+        let pagesSkipped = 0;
+        // 5. Process each source connection
+        for (const connectionId of config.sourceConnectionIds) {
+            const conn = context.connectionManager.getConnection(connectionId);
+            if (!conn || conn.status === 'paused') {
+                logger.jobLog('warn', `Skipping connection ${connectionId} (not found or paused)`, 'bookstack');
+                continue;
+            }
+            const provider = context.connectionManager.getProvider(connectionId);
+            const groups = await provider.getGroups();
+            logger.jobLog('info', `Connection "${conn.name}": ${groups.length} groups`, 'bookstack');
+            for (const group of groups) {
+                // Apply group filters
+                if (config.includeGroups && config.includeGroups.length > 0) {
+                    if (!config.includeGroups.some((g) => g.toLowerCase() === group.name.toLowerCase() || g.toLowerCase() === group.fullPath.toLowerCase())) {
+                        continue;
+                    }
+                }
+                if (config.excludeGroups && config.excludeGroups.length > 0) {
+                    if (config.excludeGroups.some((g) => g.toLowerCase() === group.name.toLowerCase() || g.toLowerCase() === group.fullPath.toLowerCase())) {
+                        continue;
+                    }
+                }
+                // Find or create shelf for this org/group
+                const shelfName = group.fullPath || group.name;
+                const shelfKey = shelfName.toLowerCase();
+                syncedShelfNames.add(shelfKey);
+                if (!syncedBookNames.has(shelfKey)) {
+                    syncedBookNames.set(shelfKey, new Set());
+                }
+                if (!shelfBookIds.has(shelfKey)) {
+                    shelfBookIds.set(shelfKey, []);
+                }
+                let shelf = shelfMap.get(shelfKey);
+                if (!shelf) {
+                    shelf = await bookstack.createShelf({
+                        name: shelfName,
+                        description: group.description || `Documentation for ${shelfName}`,
+                    });
+                    shelfMap.set(shelfKey, shelf);
+                    logger.jobLog('info', `Created shelf: ${shelfName}`, 'bookstack');
+                }
+                // Get projects in this group
+                const projects = await provider.getGroupProjects(group.id);
+                // Process repos in batches
+                for (let i = 0; i < projects.length; i += BATCH_SIZE) {
+                    if (i > 0)
+                        await new Promise((r) => setTimeout(r, BATCH_DELAY_MS));
+                    const batch = projects.slice(i, i + BATCH_SIZE);
+                    const results = await Promise.all(batch.map((project) => {
+                        const bookName = `@${group.fullPath}/${project.name}`;
+                        syncedBookNames.get(shelfKey).add(bookName.toLowerCase());
+                        return this.syncRepoAsBook(provider, bookstack, context.storageManager, project, bookName, config, group.visibility, oldHashes, newHashes);
+                    }));
+                    for (const result of results) {
+                        if (result) {
+                            shelfBookIds.get(shelfKey).push(result.bookId);
+                            pagesCreated += result.created;
+                            pagesUpdated += result.updated;
+                            pagesSkipped += result.skipped;
+                        }
+                    }
+                }
+                // Assign all synced books to this shelf (only if book list changed)
+                const bookIds = shelfBookIds.get(shelfKey);
+                if (bookIds.length > 0) {
+                    const shelfHashKey = `__shelf__${shelfKey}`;
+                    const desiredShelfState = bookIds.slice().sort((a, b) => a - b).join(',');
+                    if (oldHashes[shelfHashKey] !== desiredShelfState) {
+                        await shelf.update({ books: bookIds });
+                        logger.jobLog('info', `Updated shelf "${shelfName}" book assignments`, 'bookstack');
+                    }
+                    newHashes[shelfHashKey] = desiredShelfState;
+                }
+            }
+        }
+        // 6. Deletion reconciliation
+        if (config.propagateDeletes) {
+            await this.reconcileDeletes(bookstack, shelfMap, syncedShelfNames, syncedBookNames);
+        }
+        // 7. Persist updated content hashes
+        await context.storageManager.setJSON(hashKey, newHashes);
+        logger.jobLog('success', `Sync complete — ${pagesCreated} created, ${pagesUpdated} updated, ${pagesSkipped} unchanged`, 'bookstack');
+    }
+    /**
+     * Syncs a single git repository as a BookStack Book.
+     * Returns book ID + page stats, or null if skipped (no docs).
+     */
+    async syncRepoAsBook(provider, bookstack, storageManager, project, bookName, config, groupVisibility, oldHashes, newHashes) {
+        try {
+            // 0. Collect tags from package.json keywords + git repo topics
+            const tags = await this.collectTags(provider, project);
+            // Collect all pages to sync for this repo
+            const pagesToSync = [];
+            // 1. Fetch explicit root files (e.g. readme.md)
+            for (const filePath of config.filePaths) {
+                let content = await provider.getFileContent(project.fullPath, filePath);
+                if (content) {
+                    content = stripRedundantHeading(content, bookName);
+                    const tagsStr = tags.map((t) => t.name).join(',');
+                    const hash = await sha256(content + '\0' + tagsStr);
+                    const pageName = `${filePath} for ${bookName}`;
+                    pagesToSync.push({ name: pageName, content, hash });
+                    newHashes[pageName.toLowerCase()] = hash;
+                }
+            }
+            // 2. Scan doc directories for .md files
+            for (const dir of config.docDirs) {
+                const entries = await provider.getDirectoryContents(project.fullPath, dir);
+                if (!entries)
+                    continue;
+                const mdFiles = entries.filter((e) => e.type === 'file' && e.name.toLowerCase().endsWith('.md'));
+                for (const mdFile of mdFiles) {
+                    let content = await provider.getFileContent(project.fullPath, mdFile.path);
+                    if (content) {
+                        content = stripRedundantHeading(content, bookName);
+                        const tagsStr = tags.map((t) => t.name).join(',');
+                        const hash = await sha256(content + '\0' + tagsStr);
+                        const pageName = `${mdFile.path} for ${bookName}`;
+                        pagesToSync.push({ name: pageName, content, hash });
+                        newHashes[pageName.toLowerCase()] = hash;
+                    }
+                }
+            }
+            // Skip repos that have no docs at all
+            if (pagesToSync.length === 0)
+                return null;
+            // 3. Find or create book for this repo
+            const book = await this.findOrCreateBook(bookstack, bookName, project.description || '');
+            // 4. Get existing pages in this book
+            const existingPages = await book.getPages();
+            const pageMap = new Map();
+            for (const p of existingPages) {
+                pageMap.set(p.name.toLowerCase(), p);
+            }
+            // 5. Create or update pages (only if content changed)
+            let created = 0;
+            let updated = 0;
+            let skipped = 0;
+            const syncedPageNames = new Set();
+            for (const page of pagesToSync) {
+                syncedPageNames.add(page.name.toLowerCase());
+                const existing = pageMap.get(page.name.toLowerCase());
+                if (existing) {
+                    // Check hash — skip update if content hasn't changed
+                    const oldHash = oldHashes[page.name.toLowerCase()];
+                    if (oldHash === page.hash) {
+                        skipped++;
+                        continue;
+                    }
+                    await existing.update({ markdown: page.content, tags });
+                    updated++;
+                }
+                else {
+                    await bookstack.createPage({
+                        book_id: book.id,
+                        name: page.name,
+                        markdown: page.content,
+                        tags,
+                    });
+                    created++;
+                }
+            }
+            // 6. Delete stale pages within this book
+            if (config.propagateDeletes) {
+                for (const [name, page] of pageMap) {
+                    if (!syncedPageNames.has(name)) {
+                        await page.delete();
+                        logger.jobLog('warn', `Deleted stale page "${page.name}" from book "${bookName}"`, 'bookstack');
+                    }
+                }
+            }
+            // 7. Sync visibility — only update permissions if visibility state changed
+            if (config.syncVisibility) {
+                const isPrivate = project.visibility === 'private' || project.visibility === 'internal'
+                    || groupVisibility === 'private' || groupVisibility === 'internal';
+                const visKey = `__vis__${bookName.toLowerCase()}`;
+                const desiredVis = isPrivate ? `private:${config.privateRoleId || ''}` : 'public';
+                const oldVis = oldHashes[visKey];
+                newHashes[visKey] = desiredVis;
+                if (oldVis !== desiredVis) {
+                    if (isPrivate) {
+                        const permUpdate = {
+                            fallback_permissions: { inheriting: false, view: false, create: false, update: false, delete: false },
+                        };
+                        if (config.privateRoleId) {
+                            permUpdate.role_permissions = [{ role_id: config.privateRoleId, view: true, create: false, update: false, delete: false }];
+                        }
+                        await bookstack.updateContentPermissions('book', book.id, permUpdate);
+                        logger.jobLog('info', `Restricted book "${bookName}" (private)`, 'bookstack');
+                    }
+                    else {
+                        await bookstack.updateContentPermissions('book', book.id, {
+                            fallback_permissions: { inheriting: true },
+                        });
+                        logger.jobLog('info', `Set book "${bookName}" to public`, 'bookstack');
+                    }
+                }
+            }
+            if (created > 0 || updated > 0) {
+                logger.jobLog('info', `${bookName}: ${created} created, ${updated} updated, ${skipped} unchanged`, 'bookstack');
+            }
+            return { bookId: book.id, created, updated, skipped };
+        }
+        catch (err) {
+            logger.jobLog('warn', `Failed to sync repo ${bookName}: ${err}`, 'bookstack');
+            return null;
+        }
+    }
+    /**
+     * Removes stale BookStack shelves and orphaned books.
+     */
+    async reconcileDeletes(bookstack, shelfMap, syncedShelfNames, syncedBookNames) {
+        // Build flat set of all desired book names
+        const allDesiredBookNames = new Set();
+        for (const bookNames of syncedBookNames.values()) {
+            for (const name of bookNames) {
+                allDesiredBookNames.add(name);
+            }
+        }
+        // Delete stale shelves
+        for (const [shelfKey, shelf] of shelfMap) {
+            if (!syncedShelfNames.has(shelfKey)) {
+                await shelf.delete();
+                logger.jobLog('warn', `Deleted stale shelf "${shelf.name}"`, 'bookstack');
+            }
+        }
+        // Delete all orphaned books
+        const allBooks = await bookstack.getBooks();
+        for (const book of allBooks) {
+            if (!allDesiredBookNames.has(book.name.toLowerCase())) {
+                await book.delete();
+                logger.jobLog('warn', `Deleted orphaned book "${book.name}"`, 'bookstack');
+            }
+        }
+    }
+    /**
+     * Collects tags from package.json keywords + git repo topics, deduplicated.
+     */
+    async collectTags(provider, project) {
+        const tagNames = new Set();
+        // Add git repo topics
+        if (project.topics) {
+            for (const topic of project.topics) {
+                if (topic)
+                    tagNames.add(topic.toLowerCase());
+            }
+        }
+        // Fetch package.json and extract keywords
+        try {
+            const pkgJson = await provider.getFileContent(project.fullPath, 'package.json');
+            if (pkgJson) {
+                const pkg = JSON.parse(pkgJson);
+                if (Array.isArray(pkg.keywords)) {
+                    for (const kw of pkg.keywords) {
+                        if (typeof kw === 'string' && kw)
+                            tagNames.add(kw.toLowerCase());
+                    }
+                }
+            }
+        }
+        catch {
+            // package.json missing or invalid — no keywords
+        }
+        return Array.from(tagNames).map((name) => ({ name, value: '' }));
+    }
+    async findOrCreateBook(bookstack, bookName, description) {
+        const books = await bookstack.getBooks();
+        const existing = books.find((b) => b.name.toLowerCase() === bookName.toLowerCase());
+        if (existing)
+            return existing;
+        return bookstack.createBook({
+            name: bookName,
+            description: description || `Documentation for ${bookName}`,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autobookstackdocs.runner.js","sourceRoot":"","sources":["../../../../ts/classes/jobrunners/autobookstackdocs.runner.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes/jobrunners/base.jobrunner.d.ts

@@ -0,0 +1,14 @@
+import type * as interfaces from '../../../dist_ts_interfaces/index.js';
+import type { ConnectionManager } from '../connectionmanager.js';
+import type { StorageManager } from '../../storage/index.js';
+import type * as plugins from '../../plugins.js';
+export interface IJobRunContext {
+    jobConfig: interfaces.data.IJobConfig;
+    connectionManager: ConnectionManager;
+    storageManager: StorageManager;
+    smartSecret: plugins.smartsecret.SmartSecret;
+}
+export declare abstract class BaseJobRunner {
+    abstract readonly jobType: interfaces.data.TJobType;
+    abstract execute(context: IJobRunContext): Promise<void>;
+}

package/dist_ts/classes/jobrunners/base.jobrunner.js

@@ -0,0 +1,3 @@
+export class BaseJobRunner {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS5qb2JydW5uZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9jbGFzc2VzL2pvYnJ1bm5lcnMvYmFzZS5qb2JydW5uZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBWUEsTUFBTSxPQUFnQixhQUFhO0NBR2xDIn0=

package/dist_ts/classes/jobrunners/index.d.ts

@@ -0,0 +1,5 @@
+import type * as interfaces from '../../../dist_ts_interfaces/index.js';
+import { BaseJobRunner } from './base.jobrunner.js';
+export { BaseJobRunner, type IJobRunContext } from './base.jobrunner.js';
+export { AutoBookstackDocsRunner } from './autobookstackdocs.runner.js';
+export declare function getRunner(jobType: interfaces.data.TJobType): BaseJobRunner;

package/dist_ts/classes/jobrunners/index.js

@@ -0,0 +1,14 @@
+import { BaseJobRunner } from './base.jobrunner.js';
+import { AutoBookstackDocsRunner } from './autobookstackdocs.runner.js';
+export { BaseJobRunner } from './base.jobrunner.js';
+export { AutoBookstackDocsRunner } from './autobookstackdocs.runner.js';
+const runners = new Map();
+runners.set('autobookstackdocs', new AutoBookstackDocsRunner());
+export function getRunner(jobType) {
+    const runner = runners.get(jobType);
+    if (!runner) {
+        throw new Error(`No runner registered for job type: ${jobType}`);
+    }
+    return runner;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9jbGFzc2VzL2pvYnJ1bm5lcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3BELE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRXhFLE9BQU8sRUFBRSxhQUFhLEVBQXVCLE1BQU0scUJBQXFCLENBQUM7QUFDekUsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFFeEUsTUFBTSxPQUFPLEdBQUcsSUFBSSxHQUFHLEVBQTJDLENBQUM7QUFDbkUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxtQkFBbUIsRUFBRSxJQUFJLHVCQUF1QixFQUFFLENBQUMsQ0FBQztBQUVoRSxNQUFNLFVBQVUsU0FBUyxDQUFDLE9BQWlDO0lBQ3pELE1BQU0sTUFBTSxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDcEMsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ1osTUFBTSxJQUFJLEtBQUssQ0FBQyxzQ0FBc0MsT0FBTyxFQUFFLENBQUMsQ0FBQztJQUNuRSxDQUFDO0lBQ0QsT0FBTyxNQUFNLENBQUM7QUFDaEIsQ0FBQyJ9

package/dist_ts/classes/managedsecrets.manager.d.ts

@@ -0,0 +1,47 @@
+import * as plugins from '../plugins.js';
+import type * as interfaces from '../../dist_ts_interfaces/index.js';
+import type { StorageManager } from '../storage/index.js';
+import type { ConnectionManager } from './connectionmanager.js';
+export declare class ManagedSecretsManager {
+    private storageManager;
+    private smartSecret;
+    private connectionManager;
+    private secrets;
+    constructor(storageManager: StorageManager, smartSecret: plugins.smartsecret.SmartSecret, connectionManager: ConnectionManager);
+    init(): Promise<void>;
+    private keychainId;
+    private prefixedKey;
+    private loadSecrets;
+    private persistSecret;
+    private removeFromStorage;
+    private getSecretValue;
+    private toApiModel;
+    private pushToTargets;
+    getAll(): Promise<interfaces.data.IManagedSecret[]>;
+    getById(id: string): Promise<interfaces.data.IManagedSecret | null>;
+    create(key: string, value: string, description: string | undefined, targets: interfaces.data.IManagedSecretTarget[]): Promise<{
+        managedSecret: interfaces.data.IManagedSecret;
+        pushResults: interfaces.data.IManagedSecretTargetStatus[];
+    }>;
+    update(id: string, updates: {
+        value?: string;
+        description?: string;
+        targets?: interfaces.data.IManagedSecretTarget[];
+    }): Promise<{
+        managedSecret: interfaces.data.IManagedSecret;
+        pushResults: interfaces.data.IManagedSecretTargetStatus[];
+    }>;
+    delete(id: string): Promise<{
+        ok: boolean;
+        deleteResults: interfaces.data.IManagedSecretTargetStatus[];
+    }>;
+    pushOne(id: string): Promise<{
+        managedSecret: interfaces.data.IManagedSecret;
+        pushResults: interfaces.data.IManagedSecretTargetStatus[];
+    }>;
+    pushAll(): Promise<Array<{
+        managedSecretId: string;
+        key: string;
+        pushResults: interfaces.data.IManagedSecretTargetStatus[];
+    }>>;
+}