@doxbrix/doxloop 0.1.4 → 0.2.0

package/dist/settings.d.ts

@@ -2,5 +2,5 @@ import { type PromptIo } from './prompts.js';
 import type { DeploymentConfig, DoxloopProject } from './types.js';
 export declare function runSettingsWizard(root: string, cwd: string, io?: PromptIo): Promise<void>;
 export declare function formatProjectSettings(root: string, project: DoxloopProject): string;
-export declare function effectiveDeployment(project: DoxloopProject, fallbackApiUrl?: string): Required<DeploymentConfig>;
+export declare function effectiveDeployment(project: DoxloopProject, fallbackApiUrl?: string): Required<Pick<DeploymentConfig, 'target' | 'name' | 'slug' | 'visibility' | 'apiUrl'>> & Omit<DeploymentConfig, 'target' | 'name' | 'slug' | 'visibility' | 'apiUrl'>;
 //# sourceMappingURL=settings.d.ts.map

package/dist/settings.js

@@ -2,8 +2,10 @@ import { relative, resolve } from 'node:path';
 import { detectAgents } from './agents.js';
 import { apiUrl } from './auth.js';
 import { generatorCatalogEntry } from './generators.js';
-import { isSpecUrl, loadProject, parseDesignReference, parseSpec, saveProjectSettings, validateProjectSourceBoundaries, } from './project.js';
-import { heading, note, promptConfirm, promptSelect, promptText, } from './prompts.js';
+import { isSpecUrl, loadProject, parseDesignReference, parseSpec, projectDefaultModel, saveProjectSettings, validateProjectSourceBoundaries, } from './project.js';
+import { heading, note, promptConfirm, promptSecret, promptSelect, promptText, } from './prompts.js';
+import { captureAuthStatus, removeCaptureCredentials, removeCaptureSession, saveCaptureCredentials, saveCaptureSession, } from './capture-auth.js';
+import { startCaptureSignIn } from './screen-capture-provider.js';
 export async function runSettingsWizard(root, cwd, io = { input: process.stdin, output: process.stdout }) {
     heading(io, 'Doxloop — project settings');
     while (true) {
@@ -60,17 +62,23 @@ export function formatProjectSettings(root, project) {
     const evidence = project.sources.length === 0
         ? 'None configured'
         : project.sources
-            .map((source) => `${source.name}: ${(source.kind ?? 'directory') === 'openapi' ? 'OpenAPI ' : ''}${source.path}`)
+            .map((source) => `${source.name}: ${(source.kind ?? 'directory') === 'openapi' ? 'OpenAPI ' : (source.kind ?? 'directory') === 'docs-site' ? 'Docs site ' : ''}${source.site?.url ?? source.path}`)
             .join('\n  ');
     const deployment = effectiveDeployment(project);
-    return `Project\n  Root: ${root}\n  Title: ${project.title}\n  Generator: ${generator}\n  Agent: ${project.defaultAgent ?? 'Choose at authoring time'}\n\nEvidence\n  ${evidence}\n\nDocumentation\n  Audience: ${project.documentation.primaryAudience ?? 'Agent will determine'}\n  Locale: ${project.documentation.locale}\n  Tone: ${project.documentation.tone.join(', ')}\n\nApplication screenshots\n  ${project.application ? `${project.application.screenshots?.policy ?? 'requested'} at ${project.application.baseUrl}` : 'Not configured'}\n\nDeployment\n  Name: ${deployment.name}\n  Slug: ${deployment.slug}\n  Visibility: ${deployment.visibility}\n  Destination: ${deployment.apiUrl}`;
+    return `Project\n  Root: ${root}\n  Title: ${project.title}\n  Generator: ${generator}\n  Agent: ${project.defaultAgent ?? 'Choose at authoring time'}\n  Model: ${project.defaultModel ?? 'Agent default'}\n\nEvidence\n  ${evidence}\n\nDocumentation\n  Audience: ${project.documentation.primaryAudience ?? 'Agent will determine'}\n  Locale: ${project.documentation.locale}\n  Tone: ${project.documentation.tone.join(', ')}\n\nApplication screenshots\n  ${project.application ? `${project.application.screenshots?.policy ?? 'requested'} at ${project.application.baseUrl}` : 'Not configured'}\n\nDeployment\n  Target: ${deployment.target}\n  Name: ${deployment.name}\n  Slug: ${deployment.slug}\n  Visibility: ${deployment.visibility}\n  Destination: ${deployment.apiUrl}`;
 }
 export function effectiveDeployment(project, fallbackApiUrl) {
     return {
+        target: project.deployment?.target ?? 'doxbrix',
         name: project.deployment?.name?.trim() || project.title,
         slug: project.deployment?.slug?.trim() || slugify(project.title),
         visibility: project.deployment?.visibility ?? 'private',
         apiUrl: apiUrl(project.deployment?.apiUrl ?? fallbackApiUrl),
+        ...(project.deployment?.siteId ? { siteId: project.deployment.siteId } : {}),
+        ...(project.deployment?.projectId ? { projectId: project.deployment.projectId } : {}),
+        ...(project.deployment?.teamId ? { teamId: project.deployment.teamId } : {}),
+        ...(project.deployment?.branch ? { branch: project.deployment.branch } : {}),
+        ...(project.deployment?.basePath ? { basePath: project.deployment.basePath } : {}),
     };
 }
 async function editTitle(root, project, io) {
@@ -104,7 +112,7 @@ async function editEvidence(root, cwd, project, io) {
         note(io, project.sources.length === 0
             ? 'No product evidence is configured.'
             : project.sources
-                .map((source) => `${source.name}: ${(source.kind ?? 'directory') === 'openapi' ? 'OpenAPI — ' : ''}${source.path}`)
+                .map((source) => `${source.name}: ${(source.kind ?? 'directory') === 'openapi' ? 'OpenAPI — ' : (source.kind ?? 'directory') === 'docs-site' ? 'Docs site — ' : ''}${source.site?.url ?? source.path}`)
                 .join('\n'));
         return;
     }
@@ -210,8 +218,15 @@ async function editAgent(root, io) {
         })),
         io,
     });
-    await saveProjectSettings(root, { defaultAgent: agent });
-    note(io, `✓ Default agent changed to ${labels[agent]}.`);
+    const project = await loadProject(root);
+    const model = (await promptText({
+        message: `Default ${labels[agent]} model (leave blank for the agent default)`,
+        initial: projectDefaultModel(project, agent) ?? '',
+        allowEmpty: true,
+        io,
+    })).trim();
+    await saveProjectSettings(root, { defaultAgent: agent, defaultModel: model || undefined });
+    note(io, `✓ Default agent changed to ${labels[agent]}${model ? ` using ${model}` : ''}.`);
 }
 async function editDocumentation(root, documentation, io) {
     const field = await promptSelect({
@@ -328,6 +343,12 @@ async function editScreenshots(root, project, io) {
                 label: 'Screenshot policy',
                 ...(!project.application ? { disabled: 'configure an application first' } : {}),
             },
+            {
+                value: 'signin',
+                label: 'Application sign-in',
+                hint: 'browser session or test-account credentials for login pages',
+                ...(!project.application ? { disabled: 'configure an application first' } : {}),
+            },
             {
                 value: 'remove',
                 label: 'Remove application configuration',
@@ -339,6 +360,10 @@ async function editScreenshots(root, project, io) {
     });
     if (action === 'back')
         return;
+    if (action === 'signin') {
+        await editCaptureSignIn(root, project, io);
+        return;
+    }
     if (action === 'remove') {
         await saveProjectSettings(root, { application: undefined });
         note(io, '✓ Application screenshot configuration removed.');
@@ -382,6 +407,69 @@ async function editScreenshots(root, project, io) {
     });
     note(io, `✓ Screenshot policy changed to ${policy}.`);
 }
+/**
+ * Sign-in for the capture browser. Both options are stored in the user's
+ * Doxloop config home against this project, never in `.doxloop/project.json`.
+ */
+async function editCaptureSignIn(root, project, io) {
+    const application = project.application;
+    const status = await captureAuthStatus(root);
+    note(io, `Browser session: ${status.session ? `saved ${status.session.savedAt} for ${status.session.origin} (${status.session.cookies} cookies)` : 'none'}`);
+    note(io, `Credentials: ${status.credentials ? `saved for ${status.credentials.username}` : 'none'}`);
+    const action = await promptSelect({
+        message: 'Application sign-in',
+        choices: [
+            { value: 'browser', label: 'Sign in with browser', hint: 'opens Chrome; sign in by hand, including MFA or SSO' },
+            { value: 'credentials', label: 'Save test-account credentials', hint: 'typed by the capture server, never shown to the agent' },
+            { value: 'login-path', label: 'Set the sign-in route', hint: application.authentication?.loginPath ?? 'not set' },
+            { value: 'forget-session', label: 'Forget the browser session', ...(!status.session ? { disabled: 'none saved' } : {}) },
+            { value: 'forget-credentials', label: 'Remove the credentials', ...(!status.credentials ? { disabled: 'none saved' } : {}) },
+            { value: 'back', label: 'Back' },
+        ],
+        io,
+    });
+    if (action === 'back')
+        return;
+    if (action === 'browser') {
+        const session = await startCaptureSignIn(application);
+        note(io, `Chrome opened at ${session.url}. Complete the sign-in there and wait for the signed-in screen.`);
+        const save = await promptConfirm({ message: 'Save the signed-in session now?', initial: true, io });
+        if (!save) {
+            await session.cancel();
+            note(io, 'Sign-in discarded.');
+            return;
+        }
+        const state = await session.finish();
+        const stored = await saveCaptureSession(root, new URL(application.baseUrl).origin, state);
+        note(io, `✓ Browser session saved with ${stored.state.cookies.length} cookies. Capture runs start signed in.`);
+        return;
+    }
+    if (action === 'credentials') {
+        const username = await promptText({ message: 'Test account username or email', ...(status.credentials ? { initial: status.credentials.username } : {}), io });
+        const password = await promptSecret({ message: 'Test account password', io });
+        await saveCaptureCredentials(root, { username, password });
+        note(io, `✓ Credentials saved for ${username}. The agent fills the sign-in form by secret name during capture.`);
+        return;
+    }
+    if (action === 'login-path') {
+        const loginPath = await promptText({
+            message: 'Sign-in route (relative to the application URL)',
+            initial: application.authentication?.loginPath ?? '/login',
+            validate: (value) => value.startsWith('/') && !value.startsWith('//') ? undefined : 'Start with one slash.',
+            io,
+        });
+        await saveProjectSettings(root, { application: { ...application, authentication: { ...application.authentication, loginPath } } });
+        note(io, `✓ Sign-in route set to ${loginPath}.`);
+        return;
+    }
+    if (action === 'forget-session') {
+        await removeCaptureSession(root);
+        note(io, '✓ Browser session removed.');
+        return;
+    }
+    await removeCaptureCredentials(root);
+    note(io, '✓ Credentials removed.');
+}
 async function editDeployment(root, project, io) {
     const effective = effectiveDeployment(project);
     const field = await promptSelect({

package/dist/site-export.d.ts

@@ -0,0 +1,18 @@
+export interface ExportSiteOptions {
+    root: string;
+    out: string;
+    zip?: boolean;
+    basePath?: string;
+    siteUrl?: string;
+}
+export interface ExportSiteResult {
+    outputDir: string;
+    zipPath?: string;
+    files: number;
+    bytes: number;
+    sha256: string;
+    generator: string;
+}
+/** Build and copy a generator's deployable static output to a user-selected folder. */
+export declare function exportStaticSite(options: ExportSiteOptions): Promise<ExportSiteResult>;
+//# sourceMappingURL=site-export.d.ts.map

package/dist/site-export.js

@@ -0,0 +1,87 @@
+import { cp, mkdir, mkdtemp, readdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, relative, resolve, sep } from 'node:path';
+import { containedOutput, packageStaticOutput, runLocalBuild, } from './artifact-deploy.js';
+import { buildDoxbrixStaticSite } from './doxbrix-build.js';
+import { DoxloopError } from './errors.js';
+import { pathExists } from './fs.js';
+import { loadGeneratorAdapter } from './generators.js';
+import { loadProject } from './project.js';
+import { validateProject } from './validation.js';
+/** Build and copy a generator's deployable static output to a user-selected folder. */
+export async function exportStaticSite(options) {
+    const root = resolve(options.root);
+    const outputDir = resolve(options.out);
+    if (outputDir === root)
+        throw new DoxloopError('Export output cannot replace the project directory.');
+    await assertEmptyDestination(outputDir);
+    const validation = await validateProject(root);
+    if (validation.errors > 0) {
+        throw new DoxloopError(`Export stopped because documentation has ${validation.errors} validation error${validation.errors === 1 ? '' : 's'}. Run \`doxloop test\`.`);
+    }
+    const project = await loadProject(root);
+    const temporary = await mkdtemp(`${tmpdir()}/doxloop-export-`);
+    try {
+        let builtOutput;
+        if (project.generator === 'doxbrix') {
+            builtOutput = resolve(temporary, 'site');
+            await buildDoxbrixStaticSite({
+                root,
+                outDir: builtOutput,
+                ...(options.basePath ? { basePath: options.basePath } : {}),
+                ...(options.siteUrl ? { siteUrl: options.siteUrl } : {}),
+            });
+        }
+        else {
+            const adapter = await loadGeneratorAdapter(root, project);
+            const siteUrl = options.siteUrl ?? process.env.DOXLOOP_SITE_URL ?? 'https://example.com';
+            await runLocalBuild(adapter.id, adapter.build.command, root, siteUrl);
+            builtOutput = containedOutput(root, adapter.build.outputDir);
+        }
+        if (overlaps(outputDir, builtOutput)) {
+            throw new DoxloopError('Export output must be different from the generator build directory.');
+        }
+        const packaged = await packageStaticOutput(builtOutput);
+        await mkdir(dirname(outputDir), { recursive: true });
+        await cp(builtOutput, outputDir, { recursive: true, errorOnExist: true, force: false });
+        const zipPath = options.zip ? `${outputDir}.zip` : undefined;
+        if (zipPath) {
+            if (await pathExists(zipPath))
+                throw new DoxloopError(`Export archive already exists: ${zipPath}`);
+            await writeFile(zipPath, packaged.archive, { mode: 0o600 });
+        }
+        return {
+            outputDir,
+            ...(zipPath ? { zipPath } : {}),
+            files: packaged.files,
+            bytes: packaged.archive.byteLength,
+            sha256: packaged.sha256,
+            generator: project.generator,
+        };
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+}
+function overlaps(left, right) {
+    const relation = relative(left, right);
+    const reverse = relative(right, left);
+    const within = (value) => value === '' || (value !== '..' && !value.startsWith(`..${sep}`));
+    return within(relation) || within(reverse);
+}
+async function assertEmptyDestination(path) {
+    if (!(await pathExists(path)))
+        return;
+    let entries;
+    try {
+        entries = await readdir(path);
+    }
+    catch {
+        throw new DoxloopError(`Export output must be a directory: ${path}`);
+    }
+    if (entries.length > 0)
+        throw new DoxloopError(`Export output directory is not empty: ${path}`);
+    // cp with errorOnExist requires the destination not to exist.
+    await rm(path, { recursive: true });
+}
+//# sourceMappingURL=site-export.js.map

package/dist/source-connectors.d.ts

@@ -0,0 +1,33 @@
+import type { OpenApiSnapshot, SourceBinding, SourceHealth } from './types.js';
+export declare const SOURCE_CONNECTOR_API_VERSION: 1;
+export interface SourceConnectorSnapshot {
+    revision: string;
+    capturedAt: string;
+    validators?: {
+        etag?: string;
+        lastModified?: string;
+    };
+    openapi?: OpenApiSnapshot;
+}
+export interface SourceConnectorInventory {
+    identifiers: string[];
+    metadata: Record<string, string | number | string[]>;
+}
+/** Versioned provider boundary used by source validation, inventory, drift, and health. */
+export interface SourceConnector {
+    readonly id: string;
+    readonly version: typeof SOURCE_CONNECTOR_API_VERSION;
+    validate(root: string, source: SourceBinding): Promise<void>;
+    inventory(root: string, source: SourceBinding): Promise<SourceConnectorInventory>;
+    snapshot(root: string, source: SourceBinding): Promise<SourceConnectorSnapshot>;
+    detectChanges(previous: SourceConnectorSnapshot | undefined, current: SourceConnectorSnapshot): Promise<{
+        changed: boolean;
+        identifiers: string[];
+    }>;
+    evidenceIdentifiers(snapshot: SourceConnectorSnapshot): string[];
+    redact(source: SourceBinding): SourceBinding;
+    health(root: string, source: SourceBinding): Promise<SourceHealth>;
+}
+export declare function connectorForSource(source: SourceBinding): SourceConnector;
+export declare function sourceHealth(root: string, sources: SourceBinding[]): Promise<SourceHealth[]>;
+//# sourceMappingURL=source-connectors.d.ts.map

package/dist/source-connectors.js

@@ -0,0 +1,268 @@
+import { createHash } from 'node:crypto';
+import { lstat, readdir } from 'node:fs/promises';
+import { basename, resolve } from 'node:path';
+import { describeDocsSite, readDocsSiteManifest } from './docs-site.js';
+import { DoxloopError } from './errors.js';
+import { loadOpenApiSource } from './openapi.js';
+import { isSpecUrl, sourceKind } from './project.js';
+import { remoteHead } from './remote-source.js';
+import { readSyncState } from './sync.js';
+export const SOURCE_CONNECTOR_API_VERSION = 1;
+export function connectorForSource(source) {
+    const kind = sourceKind(source);
+    return kind === 'openapi' ? openApiConnector : kind === 'docs-site' ? docsSiteConnector : directoryConnector;
+}
+export async function sourceHealth(root, sources) {
+    return Promise.all(sources.map(async (source) => {
+        try {
+            return await connectorForSource(source).health(root, source);
+        }
+        catch (error) {
+            const connector = connectorForSource(source);
+            const redacted = connector.redact(source);
+            return {
+                name: source.name,
+                connector: connector.id,
+                status: 'error',
+                checkedAt: new Date().toISOString(),
+                location: redacted.remote?.repository ?? redacted.path,
+                provider: source.remote?.provider ?? connector.id,
+                ...(source.remote?.branch ? { branch: source.remote.branch } : {}),
+                ...(source.remote?.subdirectory ? { subdirectory: source.remote.subdirectory } : {}),
+                monitored: Boolean(source.remote),
+                summary: safeHealthError(error, source, root),
+                details: ['Check that the location is reachable and that read-only credentials are available in the configured environment.'],
+                ...(source.scope ? { scope: source.scope } : {}),
+            };
+        }
+    }));
+}
+const openApiConnector = {
+    id: 'openapi',
+    version: SOURCE_CONNECTOR_API_VERSION,
+    async validate(root, source) { await loadOpenApiSource(root, source); },
+    async inventory(root, source) {
+        const loaded = await loadOpenApiSource(root, source);
+        return {
+            identifiers: [
+                ...Object.keys(loaded.snapshot.operations),
+                ...Object.keys(loaded.snapshot.schemas).map((item) => `schema:${item}`),
+            ],
+            metadata: {
+                title: loaded.summary.title,
+                version: loaded.summary.version,
+                operationCount: loaded.summary.operationCount,
+                servers: loaded.summary.servers,
+                securitySchemes: loaded.summary.securitySchemes,
+                schemas: loaded.summary.schemas,
+            },
+        };
+    },
+    async snapshot(root, source) {
+        const loaded = await loadOpenApiSource(root, source);
+        return {
+            revision: loaded.hash,
+            capturedAt: new Date().toISOString(),
+            ...(loaded.etag || loaded.lastModified ? { validators: { ...(loaded.etag ? { etag: loaded.etag } : {}), ...(loaded.lastModified ? { lastModified: loaded.lastModified } : {}) } } : {}),
+            openapi: loaded.snapshot,
+        };
+    },
+    async detectChanges(previous, current) {
+        return { changed: previous?.revision !== current.revision, identifiers: this.evidenceIdentifiers(current) };
+    },
+    evidenceIdentifiers(snapshot) {
+        return snapshot.openapi ? [
+            ...Object.keys(snapshot.openapi.operations),
+            ...Object.keys(snapshot.openapi.schemas).map((item) => `schema:${item}`),
+        ] : [];
+    },
+    redact(source) {
+        if (!isSpecUrl(source.path))
+            return source;
+        const url = new URL(source.path);
+        url.search = url.search ? '?…' : '';
+        return { ...source, path: url.toString() };
+    },
+    async health(root, source) {
+        const loaded = await loadOpenApiSource(root, source);
+        const baseline = (await readSyncState(root)).sources[source.name];
+        const redacted = this.redact(source);
+        const checkedAt = new Date().toISOString();
+        return {
+            name: source.name,
+            connector: this.id,
+            status: 'healthy',
+            checkedAt,
+            lastSuccessfulAt: checkedAt,
+            ...(baseline?.recordedAt ? { lastMonitoringAt: baseline.recordedAt } : {}),
+            location: redacted.path,
+            provider: isSpecUrl(source.path) ? 'https' : 'file',
+            monitored: isSpecUrl(source.path),
+            revision: loaded.hash,
+            summary: `${loaded.summary.title} ${loaded.summary.version} · ${loaded.summary.operationCount} operations`,
+            details: [
+                `OpenAPI ${loaded.summary.specificationVersion}`,
+                `${loaded.summary.schemas.length} schemas`,
+                `${loaded.summary.securitySchemes.length} security schemes`,
+                `${loaded.summary.servers.length} servers`,
+            ],
+            openapi: loaded.summary,
+            ...(source.scope ? { scope: source.scope } : {}),
+        };
+    },
+};
+const directoryConnector = {
+    id: 'directory',
+    version: SOURCE_CONNECTOR_API_VERSION,
+    async validate(root, source) {
+        const path = resolve(root, source.path);
+        let stats;
+        try {
+            stats = await lstat(path);
+        }
+        catch {
+            throw new DoxloopError(`Source directory does not exist: ${path}`);
+        }
+        if (!stats.isDirectory() || stats.isSymbolicLink())
+            throw new DoxloopError(`Source must be a non-symlinked directory: ${path}`);
+    },
+    async inventory(root, source) {
+        await this.validate(root, source);
+        const entries = await readdir(resolve(root, source.path), { withFileTypes: true });
+        return { identifiers: entries.map((entry) => entry.name).sort(), metadata: { entries: entries.length } };
+    },
+    async snapshot(root, source) {
+        const inventory = await this.inventory(root, source);
+        return { revision: createHash('sha256').update(JSON.stringify(inventory)).digest('hex'), capturedAt: new Date().toISOString() };
+    },
+    async detectChanges(previous, current) { return { changed: previous?.revision !== current.revision, identifiers: [] }; },
+    evidenceIdentifiers() { return []; },
+    redact(source) {
+        return {
+            ...source,
+            path: basename(source.path) || source.path,
+            ...(source.remote ? { remote: { ...source.remote, repository: redactedRepository(source.remote.repository) } } : {}),
+        };
+    },
+    async health(root, source) {
+        const [snapshot, baseline, head] = await Promise.all([
+            this.snapshot(root, source),
+            readSyncState(root).then((state) => state.sources[source.name]),
+            source.remote ? remoteHead(source.remote) : Promise.resolve(undefined),
+        ]);
+        const inventory = await this.inventory(root, source);
+        const redacted = this.redact(source);
+        const checkedAt = new Date().toISOString();
+        return {
+            name: source.name,
+            connector: this.id,
+            status: 'healthy',
+            checkedAt,
+            lastSuccessfulAt: checkedAt,
+            ...(baseline?.recordedAt ? { lastMonitoringAt: baseline.recordedAt } : {}),
+            location: redacted.remote?.repository ?? redacted.path,
+            provider: source.remote?.provider ?? 'directory',
+            ...(source.remote?.branch ? { branch: source.remote.branch } : {}),
+            ...(source.remote?.subdirectory ? { subdirectory: source.remote.subdirectory } : {}),
+            monitored: Boolean(source.remote),
+            revision: head ?? snapshot.revision,
+            summary: `${inventory.metadata.entries ?? 0} top-level entries available`,
+            details: source.remote ? [`Monitored from ${source.remote.provider}:${redacted.remote?.repository}@${source.remote.branch}`] : ['Local read-only directory'],
+            ...(source.scope ? { scope: source.scope } : {}),
+        };
+    },
+};
+/**
+ * An existing documentation website, crawled into a Markdown snapshot. The
+ * snapshot is frozen at crawl time, so health reports what was crawled and
+ * change detection compares snapshot contents; a re-crawl replaces the folder.
+ */
+const docsSiteConnector = {
+    id: 'docs-site',
+    version: SOURCE_CONNECTOR_API_VERSION,
+    async validate(root, source) { await readDocsSiteManifest(root, source); },
+    async inventory(root, source) {
+        const manifest = await readDocsSiteManifest(root, source);
+        return {
+            identifiers: manifest.pages.map((page) => page.file).sort(),
+            metadata: {
+                url: manifest.url,
+                pages: manifest.totals.pages,
+                words: manifest.totals.words,
+                crawledAt: manifest.crawledAt,
+                ...(manifest.generator ? { generator: manifest.generator } : {}),
+            },
+        };
+    },
+    async snapshot(root, source) {
+        const manifest = await readDocsSiteManifest(root, source);
+        return { revision: manifest.hash, capturedAt: manifest.crawledAt };
+    },
+    async detectChanges(previous, current) { return { changed: previous?.revision !== current.revision, identifiers: [] }; },
+    evidenceIdentifiers() { return []; },
+    redact(source) {
+        if (!source.site)
+            return source;
+        try {
+            const url = new URL(source.site.url);
+            url.search = url.search ? '?…' : '';
+            return { ...source, site: { ...source.site, url: url.toString() } };
+        }
+        catch {
+            return source;
+        }
+    },
+    async health(root, source) {
+        const manifest = await readDocsSiteManifest(root, source);
+        const baseline = (await readSyncState(root)).sources[source.name];
+        const checkedAt = new Date().toISOString();
+        const site = source.site ?? { url: manifest.url, crawledAt: manifest.crawledAt, pages: manifest.totals.pages, words: manifest.totals.words, hash: manifest.hash };
+        const stale = source.site !== undefined && source.site.hash !== manifest.hash;
+        return {
+            name: source.name,
+            connector: this.id,
+            status: stale ? 'warning' : 'healthy',
+            checkedAt,
+            lastSuccessfulAt: checkedAt,
+            ...(baseline?.recordedAt ? { lastMonitoringAt: baseline.recordedAt } : {}),
+            location: this.redact(source).site?.url ?? manifest.url,
+            provider: 'https',
+            monitored: false,
+            revision: manifest.hash,
+            summary: stale ? `Snapshot on disk differs from the recorded crawl; re-crawl the site.` : describeDocsSite(site),
+            details: [
+                `Existing documentation site: ${manifest.url}`,
+                `${manifest.totals.pages} pages, ${manifest.totals.words} words${manifest.generator ? `, ${manifest.generator}` : ''}`,
+                `Discovered through ${manifest.discovery.length > 0 ? manifest.discovery.join(', ') : 'the entry page'}`,
+                ...(manifest.truncated ? [`Crawl stopped at the ${manifest.pageLimit}-page limit.`] : []),
+                ...(manifest.brokenLinks.length > 0 ? [`${manifest.brokenLinks.length} broken internal links`] : []),
+                'Frozen at crawl time; use Re-crawl to refresh.',
+            ],
+            docsSite: { ...site, brokenLinks: manifest.brokenLinks.length },
+            ...(source.scope ? { scope: source.scope } : {}),
+        };
+    },
+};
+function redactedRepository(value) {
+    try {
+        const url = new URL(value);
+        if (url.username)
+            url.username = '…';
+        url.password = '';
+        url.search = url.search ? '?…' : '';
+        url.hash = '';
+        return url.toString();
+    }
+    catch {
+        return value;
+    }
+}
+function safeHealthError(error, source, root) {
+    let value = error instanceof Error ? error.message : String(error);
+    for (const secret of [resolve(root, source.path), source.path, source.remote?.repository]) {
+        if (secret)
+            value = value.split(secret).join(connectorForSource(source).redact(source).remote?.repository ?? connectorForSource(source).redact(source).path);
+    }
+    return value.replace(/([?&](?:token|key|secret|password|signature)=)[^&\s]+/gi, '$1…').slice(0, 500);
+}
+//# sourceMappingURL=source-connectors.js.map