ghcr-manager-visualizer 0.0.1-dev.0

package/dist/src/_graph-repository.js

@@ -0,0 +1,399 @@
+import { placeholders } from "./_sql-placeholders.js";
+export class GraphRepository {
+    #database;
+    constructor(database) {
+        this.#database = database;
+    }
+    listOwners() {
+        return this.#database
+            .prepare(`
+          SELECT DISTINCT owner
+          FROM package_scans
+          WHERE status = 'completed'
+          ORDER BY owner
+        `)
+            .all();
+    }
+    listPackages(owner) {
+        return this.#database
+            .prepare(`
+          SELECT DISTINCT package_name AS packageName
+          FROM package_scans
+          WHERE status = 'completed'
+            AND owner = ?
+          ORDER BY package_name
+        `)
+            .all(owner);
+    }
+    listScans(owner, packageName) {
+        return this.#database
+            .prepare(`
+          SELECT scan_id AS scanId, scan_completed_at AS scanCompletedAt
+          FROM package_scans
+          WHERE status = 'completed'
+            AND owner = ?
+            AND package_name = ?
+          ORDER BY scan_completed_at DESC, scan_id DESC
+        `)
+            .all(owner, packageName);
+    }
+    listTags(owner, packageName, scanId, compareScanId, query, limit) {
+        const resolvedScans = this.#resolveScans(owner, packageName, scanId, compareScanId);
+        const normalizedLimit = Math.max(1, Math.min(limit, 50));
+        const normalizedQuery = query.trim();
+        if (normalizedQuery === "") {
+            return [];
+        }
+        const scanInClause = placeholders(resolvedScans.scanIds.length);
+        return this.#database
+            .prepare(`
+          SELECT DISTINCT tag AS tagName
+          FROM tags
+          WHERE scan_id IN (${scanInClause})
+            AND is_digest_tag = 0
+            AND tag LIKE ? ESCAPE '\\'
+          ORDER BY tag
+          LIMIT ?
+        `)
+            .all(...resolvedScans.scanIds, `%${_escapeLikeValue(normalizedQuery)}%`, normalizedLimit);
+    }
+    resolveLatestScanId(owner, packageName) {
+        const row = this.#database
+            .prepare(`
+          SELECT scan_id
+          FROM v_latest_scan_per_package
+          WHERE owner = ?
+            AND package_name = ?
+          LIMIT 1
+        `)
+            .get(owner, packageName);
+        if (!row) {
+            throw new Error(`database does not contain completed package scan for ${owner}/${packageName}`);
+        }
+        return row.scan_id;
+    }
+    resolveScanId(owner, packageName, scanId) {
+        if (scanId === undefined) {
+            return this.resolveLatestScanId(owner, packageName);
+        }
+        const row = this.#database
+            .prepare(`
+          SELECT scan_id
+          FROM package_scans
+          WHERE scan_id = ?
+            AND owner = ?
+            AND package_name = ?
+            AND status = 'completed'
+          LIMIT 1
+        `)
+            .get(scanId, owner, packageName);
+        if (!row) {
+            throw new Error(`scan ${scanId} is not a completed scan for ${owner}/${packageName}`);
+        }
+        return row.scan_id;
+    }
+    resolveManifest(owner, packageName, scanId, compareScanId, args) {
+        const resolvedScans = this.#resolveScans(owner, packageName, scanId, compareScanId);
+        const digest = args.digest ??
+            this.#resolveDigestByTag(resolvedScans.scanIds, args.tag, resolvedScans.scanId, resolvedScans.compareScanId);
+        const node = this.#readManifestMap(resolvedScans.scanIds, [digest], true, resolvedScans.newerScanId, resolvedScans.olderScanId).get(digest);
+        if (!node) {
+            throw new Error(`manifest ${digest} was not found in ${owner}/${packageName}`);
+        }
+        return {
+            owner,
+            packageName,
+            scanId: resolvedScans.scanId,
+            compareScanId: resolvedScans.compareScanId,
+            digest: node.digest,
+            versionId: node.versionId,
+            manifestKind: node.manifestKind,
+            tags: node.tags.map((tag) => tag.name)
+        };
+    }
+    getManifest(owner, packageName, scanId, compareScanId, digest) {
+        const resolvedScans = this.#resolveScans(owner, packageName, scanId, compareScanId);
+        const node = this.#readManifestMap(resolvedScans.scanIds, [digest], true, resolvedScans.newerScanId, resolvedScans.olderScanId).get(digest);
+        if (!node) {
+            throw new Error(`manifest ${digest} was not found in ${owner}/${packageName}`);
+        }
+        return node;
+    }
+    getGraph(owner, packageName, scanId, compareScanId, centerDigest, depth) {
+        const resolvedScans = this.#resolveScans(owner, packageName, scanId, compareScanId);
+        const normalizedDepth = Math.max(0, depth);
+        const visited = new Set([centerDigest]);
+        let frontier = new Set([centerDigest]);
+        for (let currentDepth = 0; currentDepth < normalizedDepth && frontier.size > 0; currentDepth += 1) {
+            const edgeRows = this.#readAdjacentEdges(resolvedScans.scanIds, [...frontier]);
+            const nextFrontier = new Set();
+            for (const row of edgeRows) {
+                if (!visited.has(row.parent_digest)) {
+                    visited.add(row.parent_digest);
+                    nextFrontier.add(row.parent_digest);
+                }
+                if (!visited.has(row.child_digest)) {
+                    visited.add(row.child_digest);
+                    nextFrontier.add(row.child_digest);
+                }
+            }
+            frontier = nextFrontier;
+        }
+        const nodes = [
+            ...this.#readManifestMap(resolvedScans.scanIds, [...visited], false, resolvedScans.newerScanId, resolvedScans.olderScanId).values()
+        ];
+        const edges = this.#readVisibleEdges(resolvedScans.scanIds, [...visited]).map((row) => ({
+            id: `${row.parent_digest}|${row.child_digest}|${row.edge_kind}`,
+            from: row.parent_digest,
+            to: row.child_digest,
+            kind: row.edge_kind
+        }));
+        if (!nodes.some((node) => node.digest === centerDigest)) {
+            throw new Error(`manifest ${centerDigest} was not found in ${owner}/${packageName}`);
+        }
+        return {
+            owner,
+            packageName,
+            scanId: resolvedScans.scanId,
+            compareScanId: resolvedScans.compareScanId,
+            centerDigest,
+            depth: normalizedDepth,
+            nodes,
+            edges: edges.sort((left, right) => left.id.localeCompare(right.id))
+        };
+    }
+    #resolveScans(owner, packageName, scanId, compareScanId) {
+        const resolvedScanId = this.resolveScanId(owner, packageName, scanId);
+        if (compareScanId === undefined || compareScanId === resolvedScanId) {
+            return {
+                scanId: resolvedScanId,
+                scanIds: [resolvedScanId],
+                newerScanId: resolvedScanId
+            };
+        }
+        const resolvedCompareScanId = this.resolveScanId(owner, packageName, compareScanId);
+        const rows = this.#database
+            .prepare(`
+          SELECT scan_id, scan_completed_at
+          FROM package_scans
+          WHERE owner = ?
+            AND package_name = ?
+            AND scan_id IN (?, ?)
+          ORDER BY scan_completed_at, scan_id
+        `)
+            .all(owner, packageName, resolvedScanId, resolvedCompareScanId);
+        if (rows.length !== 2) {
+            throw new Error(`failed to resolve compare scans for ${owner}/${packageName}`);
+        }
+        return {
+            scanId: resolvedScanId,
+            compareScanId: resolvedCompareScanId,
+            scanIds: [resolvedScanId, resolvedCompareScanId],
+            newerScanId: rows[1].scan_id,
+            olderScanId: rows[0].scan_id
+        };
+    }
+    #resolveDigestByTag(scanIds, tag, preferredScanId, fallbackScanId) {
+        if (!tag) {
+            throw new Error("either digest or tag is required");
+        }
+        const scanInClause = placeholders(scanIds.length);
+        const row = this.#database
+            .prepare(`
+          SELECT manifest.digest
+          FROM tags
+          JOIN manifests manifest
+            ON manifest.scan_id = tags.scan_id
+           AND manifest.version_id = tags.version_id
+          WHERE tags.scan_id IN (${scanInClause})
+            AND tags.tag = ?
+          ORDER BY
+            CASE
+              WHEN tags.scan_id = ? THEN 0
+              WHEN ? IS NOT NULL AND tags.scan_id = ? THEN 1
+              ELSE 2
+            END
+          LIMIT 1
+        `)
+            .get(...scanIds, tag, preferredScanId, fallbackScanId ?? null, fallbackScanId ?? -1);
+        if (!row) {
+            throw new Error(`tag ${tag} was not found in selected scan context`);
+        }
+        return row.digest;
+    }
+    #readAdjacentEdges(scanIds, digests) {
+        const scanInClause = placeholders(scanIds.length);
+        const inClause = placeholders(digests.length);
+        const sql = `
+      SELECT DISTINCT parent_digest, child_digest, edge_kind
+      FROM manifest_edges
+      WHERE scan_id IN (${scanInClause})
+        AND (parent_digest IN (${inClause}) OR child_digest IN (${inClause}))
+      ORDER BY parent_digest, child_digest, edge_kind
+    `;
+        return this.#database.prepare(sql).all(...scanIds, ...digests, ...digests);
+    }
+    #readVisibleEdges(scanIds, digests) {
+        const scanInClause = placeholders(scanIds.length);
+        const inClause = placeholders(digests.length);
+        const sql = `
+      SELECT DISTINCT parent_digest, child_digest, edge_kind
+      FROM manifest_edges
+      WHERE scan_id IN (${scanInClause})
+        AND parent_digest IN (${inClause})
+        AND child_digest IN (${inClause})
+      ORDER BY parent_digest, child_digest, edge_kind
+    `;
+        return this.#database.prepare(sql).all(...scanIds, ...digests, ...digests);
+    }
+    #readManifestMap(scanIds, digests, includePayload, newerScanId, olderScanId) {
+        const scanInClause = placeholders(scanIds.length);
+        const inClause = placeholders(digests.length);
+        const payloadColumn = includePayload ? "payload.raw_json" : "NULL";
+        const sql = `
+      WITH ranked_platforms AS (
+        SELECT
+          scan_id,
+          child_digest,
+          platform_os,
+          platform_architecture,
+          platform_variant,
+          ROW_NUMBER() OVER (
+            PARTITION BY scan_id, child_digest
+            ORDER BY parent_digest
+          ) AS row_number
+        FROM manifest_descriptors
+        WHERE scan_id IN (${scanInClause})
+          AND child_digest IN (${inClause})
+          AND (
+            platform_os IS NOT NULL
+            OR platform_architecture IS NOT NULL
+            OR platform_variant IS NOT NULL
+          )
+      )
+      SELECT
+        manifest.scan_id,
+        manifest.digest,
+        manifest.version_id,
+        package_version.created_at,
+        package_version.updated_at,
+        manifest.manifest_kind,
+        manifest.media_type,
+        platform.platform_os,
+        platform.platform_architecture,
+        platform.platform_variant,
+        manifest.artifact_type,
+        manifest.subject_digest,
+        ${payloadColumn} AS raw_json,
+        tag.tag
+      FROM manifests manifest
+      JOIN package_versions package_version
+        ON package_version.scan_id = manifest.scan_id
+       AND package_version.version_id = manifest.version_id
+      LEFT JOIN manifest_payloads payload
+        ON payload.scan_id = manifest.scan_id
+       AND payload.digest = manifest.digest
+      LEFT JOIN tags tag
+        ON tag.scan_id = manifest.scan_id
+       AND tag.version_id = manifest.version_id
+       AND tag.is_digest_tag = 0
+      LEFT JOIN ranked_platforms platform
+        ON platform.scan_id = manifest.scan_id
+       AND platform.child_digest = manifest.digest
+       AND platform.row_number = 1
+      WHERE manifest.scan_id IN (${scanInClause})
+        AND manifest.digest IN (${inClause})
+      ORDER BY manifest.digest, CASE WHEN manifest.scan_id = ? THEN 0 ELSE 1 END, tag.tag
+    `;
+        const rows = this.#database
+            .prepare(sql)
+            .all(...scanIds, ...digests, ...scanIds, ...digests, newerScanId);
+        const manifests = new Map();
+        const scanMemberships = new Map();
+        const tagsByDigest = new Map();
+        for (const row of rows) {
+            let scanMembership = scanMemberships.get(row.digest);
+            if (!scanMembership) {
+                scanMembership = new Set();
+                scanMemberships.set(row.digest, scanMembership);
+            }
+            scanMembership.add(row.scan_id);
+            let manifest = manifests.get(row.digest);
+            if (!manifest || row.scan_id === newerScanId) {
+                manifest = {
+                    id: row.digest,
+                    digest: row.digest,
+                    versionId: row.version_id,
+                    createdAt: row.created_at,
+                    updatedAt: row.updated_at,
+                    manifestKind: row.manifest_kind,
+                    mediaType: row.media_type,
+                    displayPlatform: _formatPlatform(row.platform_os, row.platform_architecture, row.platform_variant),
+                    artifactType: row.artifact_type,
+                    subjectDigest: row.subject_digest,
+                    tags: [],
+                    changeStatus: "unchanged",
+                    rawJson: row.raw_json
+                };
+                manifests.set(row.digest, manifest);
+            }
+            if (row.tag) {
+                let tags = tagsByDigest.get(row.digest);
+                if (!tags) {
+                    tags = new Map();
+                    tagsByDigest.set(row.digest, tags);
+                }
+                let tagScans = tags.get(row.tag);
+                if (!tagScans) {
+                    tagScans = new Set();
+                    tags.set(row.tag, tagScans);
+                }
+                tagScans.add(row.scan_id);
+            }
+        }
+        for (const [digest, manifest] of manifests) {
+            const tagMap = tagsByDigest.get(digest) ?? new Map();
+            manifest.changeStatus = _resolveChangeStatus(scanMemberships.get(digest) ?? new Set(), newerScanId, olderScanId);
+            manifest.tags = [...tagMap.entries()]
+                .map(([name, tagScans]) => ({
+                name,
+                changeStatus: _resolveChangeStatus(tagScans, newerScanId, olderScanId)
+            }))
+                .sort((left, right) => left.name.localeCompare(right.name));
+        }
+        return manifests;
+    }
+}
+function _resolveChangeStatus(scanIds, newerScanId, olderScanId) {
+    if (olderScanId === undefined) {
+        return "unchanged";
+    }
+    const hasNewer = scanIds.has(newerScanId);
+    const hasOlder = scanIds.has(olderScanId);
+    if (hasNewer && hasOlder) {
+        return "unchanged";
+    }
+    return hasNewer ? "added" : "removed";
+}
+function _formatPlatform(os, architecture, variant) {
+    const normalizedOs = _normalizePlatformPart(os);
+    const normalizedArchitecture = _normalizePlatformPart(architecture);
+    const normalizedVariant = _normalizePlatformPart(variant);
+    if (!normalizedOs && !normalizedArchitecture && !normalizedVariant) {
+        return null;
+    }
+    const platform = [normalizedOs, normalizedArchitecture].filter((value) => value).join("/");
+    if (normalizedVariant) {
+        return platform ? `${platform}/${normalizedVariant}` : normalizedVariant;
+    }
+    return platform || null;
+}
+function _normalizePlatformPart(value) {
+    if (!value || value === "unknown") {
+        return null;
+    }
+    return value;
+}
+function _escapeLikeValue(value) {
+    return value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+}

package/dist/src/_server.d.ts

@@ -0,0 +1,14 @@
+export interface VisualizerServerOptions {
+    databasePath: string;
+    host: string;
+    port: number;
+}
+export interface VisualizerServerHandle {
+    readonly url: string;
+    close(): Promise<void>;
+}
+export declare function startVisualizerServer(options: VisualizerServerOptions): Promise<VisualizerServerHandle>;
+export declare function _resolveRuntimePaths(importMetaUrl: string): {
+    publicDirectory: string;
+    cytoscapePath: string;
+};

package/dist/src/_server.js

@@ -0,0 +1,158 @@
+import Database from "better-sqlite3";
+import { createReadStream, existsSync } from "node:fs";
+import { stat } from "node:fs/promises";
+import { createServer } from "node:http";
+import { extname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { GraphRepository } from "./_graph-repository.js";
+const _mimeTypes = new Map([
+    [".css", "text/css; charset=utf-8"],
+    [".html", "text/html; charset=utf-8"],
+    [".js", "text/javascript; charset=utf-8"],
+    [".json", "application/json; charset=utf-8"],
+    [".mjs", "text/javascript; charset=utf-8"]
+]);
+export async function startVisualizerServer(options) {
+    const database = new Database(options.databasePath, { readonly: true, fileMustExist: true });
+    const repository = new GraphRepository(database);
+    const runtimePaths = _resolveRuntimePaths(import.meta.url);
+    const server = createServer(async (request, response) => {
+        const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "localhost"}`);
+        try {
+            if (url.pathname.startsWith("/api/")) {
+                _writeJson(response, 200, _handleApi(repository, url));
+                return;
+            }
+            if (url.pathname === "/vendor/cytoscape.js") {
+                await _streamFile(response, runtimePaths.cytoscapePath);
+                return;
+            }
+            const requestedPath = url.pathname === "/" ? "/index.html" : url.pathname;
+            const staticPath = resolve(runtimePaths.publicDirectory, `.${requestedPath}`);
+            if (!staticPath.startsWith(runtimePaths.publicDirectory)) {
+                throw Object.assign(new Error("not found"), { code: "ENOENT" });
+            }
+            await _streamFile(response, staticPath);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                _writeJson(response, 404, { error: "not found" });
+                return;
+            }
+            const message = error instanceof Error ? error.message : "unexpected error";
+            const statusCode = message.includes("not found") || message.includes("required") ? 404 : 400;
+            _writeJson(response, statusCode, { error: message });
+        }
+    });
+    let url = "";
+    await new Promise((resolvePromise) => {
+        server.listen(options.port, options.host, () => {
+            const address = server.address();
+            if (typeof address === "object" && address) {
+                url = `http://${options.host}:${address.port}`;
+                console.log(`Visualizer listening at ${url}`);
+            }
+            resolvePromise();
+        });
+    });
+    return {
+        url,
+        async close() {
+            await new Promise((resolvePromise, rejectPromise) => {
+                server.close((error) => {
+                    if (error) {
+                        rejectPromise(error);
+                        return;
+                    }
+                    resolvePromise();
+                });
+            });
+            database.close();
+        }
+    };
+}
+export function _resolveRuntimePaths(importMetaUrl) {
+    const baseDirectory = resolve(fileURLToPath(new URL("..", importMetaUrl)));
+    return {
+        publicDirectory: join(baseDirectory, "public"),
+        cytoscapePath: join(baseDirectory, "..", "node_modules", "cytoscape", "dist", "cytoscape.esm.min.mjs")
+    };
+}
+function _handleApi(repository, url) {
+    const segments = url.pathname.split("/").filter(Boolean);
+    if (segments.length === 2 && segments[0] === "api" && segments[1] === "owners") {
+        return repository.listOwners();
+    }
+    if (segments.length === 4 && segments[0] === "api" && segments[1] === "owners" && segments[3] === "packages") {
+        return repository.listPackages(decodeURIComponent(segments[2]));
+    }
+    if (segments.length === 5 && segments[0] === "api" && segments[1] === "packages" && segments[4] === "scans") {
+        return repository.listScans(decodeURIComponent(segments[2]), decodeURIComponent(segments[3]));
+    }
+    if (segments.length < 4 || segments[0] !== "api" || segments[1] !== "packages") {
+        throw new Error("not found");
+    }
+    const owner = decodeURIComponent(segments[2]);
+    const packageName = decodeURIComponent(segments[3]);
+    const scanId = _parseOptionalInteger(url.searchParams.get("scan_id"));
+    const compareScanId = _parseOptionalInteger(url.searchParams.get("compare_scan_id"));
+    if (segments.length === 5 && segments[4] === "tags") {
+        return repository.listTags(owner, packageName, scanId, compareScanId, url.searchParams.get("q") ?? "", _parseOptionalInteger(url.searchParams.get("limit")) ?? 20);
+    }
+    if (segments.length === 6 && segments[4] === "scans" && segments[5] === "latest") {
+        return { scanId: repository.resolveLatestScanId(owner, packageName) };
+    }
+    if (segments.length === 5 && segments[4] === "manifests" && url.searchParams.has("digest")) {
+        return repository.resolveManifest(owner, packageName, scanId, compareScanId, {
+            digest: url.searchParams.get("digest") ?? undefined
+        });
+    }
+    if (segments.length === 5 && segments[4] === "manifests" && url.searchParams.has("tag")) {
+        return repository.resolveManifest(owner, packageName, scanId, compareScanId, {
+            tag: url.searchParams.get("tag") ?? undefined
+        });
+    }
+    if (segments.length === 6 && segments[4] === "manifests") {
+        return repository.getManifest(owner, packageName, scanId, compareScanId, decodeURIComponent(segments[5]));
+    }
+    if (segments.length === 5 && segments[4] === "graph") {
+        const centerDigest = url.searchParams.get("center_digest");
+        if (!centerDigest) {
+            throw new Error("center_digest is required");
+        }
+        return repository.getGraph(owner, packageName, scanId, compareScanId, centerDigest, _parseOptionalInteger(url.searchParams.get("depth")) ?? 1);
+    }
+    throw new Error("not found");
+}
+function _parseOptionalInteger(raw) {
+    if (raw === null || raw === "") {
+        return undefined;
+    }
+    const value = Number.parseInt(raw, 10);
+    if (!Number.isInteger(value)) {
+        throw new Error(`invalid integer value: ${raw}`);
+    }
+    return value;
+}
+async function _streamFile(response, path) {
+    if (!existsSync(path)) {
+        throw Object.assign(new Error("not found"), { code: "ENOENT" });
+    }
+    const fileStat = await stat(path);
+    if (!fileStat.isFile()) {
+        throw Object.assign(new Error("not found"), { code: "ENOENT" });
+    }
+    response.statusCode = 200;
+    response.setHeader("Content-Type", _mimeTypes.get(extname(path)) ?? "application/octet-stream");
+    await new Promise((resolvePromise, rejectPromise) => {
+        const stream = createReadStream(path);
+        stream.on("error", rejectPromise);
+        stream.on("end", resolvePromise);
+        stream.pipe(response);
+    });
+}
+function _writeJson(response, statusCode, body) {
+    response.statusCode = statusCode;
+    response.setHeader("Content-Type", "application/json; charset=utf-8");
+    response.end(JSON.stringify(body));
+}

package/dist/src/_sql-placeholders.d.ts

@@ -0,0 +1 @@
+export declare function placeholders(count: number): string;

package/dist/src/_sql-placeholders.js

@@ -0,0 +1,6 @@
+export function placeholders(count) {
+    if (count < 1) {
+        throw new Error("placeholder count must be positive");
+    }
+    return Array.from({ length: count }, () => "?").join(", ");
+}

package/dist/src/_types.d.ts

@@ -0,0 +1,62 @@
+export type GraphEdgeKind = "image-child" | "referrer" | "digest-tag-referrer";
+export type ChangeStatus = "unchanged" | "added" | "removed";
+export interface OwnerOption {
+    owner: string;
+}
+export interface PackageOption {
+    packageName: string;
+}
+export interface ScanOption {
+    scanId: number;
+    scanCompletedAt: string;
+}
+export interface TagOption {
+    tagName: string;
+}
+export interface GraphTag {
+    name: string;
+    changeStatus: ChangeStatus;
+}
+export interface GraphNode {
+    id: string;
+    digest: string;
+    versionId: number;
+    createdAt: string;
+    updatedAt: string;
+    manifestKind: string | null;
+    mediaType: string;
+    displayPlatform: string | null;
+    artifactType: string | null;
+    subjectDigest: string | null;
+    tags: GraphTag[];
+    changeStatus: ChangeStatus;
+}
+export interface GraphEdge {
+    id: string;
+    from: string;
+    to: string;
+    kind: GraphEdgeKind;
+}
+export interface GraphResponse {
+    owner: string;
+    packageName: string;
+    scanId: number;
+    compareScanId?: number;
+    centerDigest: string;
+    depth: number;
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+}
+export interface ManifestResolution {
+    owner: string;
+    packageName: string;
+    scanId: number;
+    compareScanId?: number;
+    digest: string;
+    versionId: number;
+    manifestKind: string | null;
+    tags: string[];
+}
+export interface ManifestDetails extends GraphNode {
+    rawJson: string | null;
+}

package/dist/src/_types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+import { startVisualizerServer } from "./_server.js";
+export type { VisualizerServerHandle } from "./_server.js";
+export interface CliOptions {
+    databasePath: string;
+    host: string;
+    port: number;
+}
+export declare function main(args: string[], startServer?: typeof startVisualizerServer): Promise<void>;
+export declare function parseArgs(args: string[]): CliOptions;
+export declare function resolveDatabasePath(databasePath: string): string;