@plebeiantech/lat.md 0.12.3-fork.9 → 0.13.4-fork.2

package/dist/src/view/server-build.js

@@ -0,0 +1,145 @@
+import { readFileSync } from 'node:fs';
+import { fork } from 'node:child_process';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getLatServerVersion } from '../../vendor/lat.md-server/index.js';
+import { analyzeMarkdownProject, } from '@plebeiantech/lat.md-core/project-analysis';
+import { getLocalVersion } from '../version.js';
+import { toPosix } from '@plebeiantech/lat.md-core/path';
+import { buildStaticView, moveViewBuildOutput, removeViewBuildStaging, normalizeStaticViewBasePath, validateViewBuildOutput, } from './static-build.js';
+import { SERVER_VIEW_SCHEMA_VERSION, } from './server-deployment.js';
+const defaultDependencies = {
+    analyzeMarkdownProject,
+    buildStaticView,
+    getLocalVersion,
+    getLatServerVersion,
+    getPackageVersion,
+    buildSearchIndex: buildServerSearchIndex,
+};
+/** Wait for the index process to exit so native handles cannot lock staging. */
+export function buildServerSearchIndex(latDir, project, cacheDir) {
+    const sourceRuntime = import.meta.url.endsWith('.ts');
+    const child = fork(new URL(sourceRuntime ? './server-index-worker.ts' : './server-index-worker.js', import.meta.url), [], {
+        execArgv: sourceRuntime ? ['--import', 'tsx'] : [],
+        serialization: 'advanced',
+        stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
+    });
+    return new Promise((resolveIndex, reject) => {
+        let stderr = '';
+        let sendError = null;
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', (chunk) => {
+            stderr = (stderr + chunk).slice(-64_000);
+        });
+        child.once('error', reject);
+        child.once('close', (code, signal) => {
+            if (sendError)
+                reject(sendError);
+            else if (code === 0)
+                resolveIndex();
+            else {
+                reject(new Error(`Server search indexing failed (${signal ?? code}): ${stderr.trim()}`));
+            }
+        });
+        child.send({ latDir, project, cacheDir }, (error) => {
+            if (error) {
+                sendError = error;
+                child.kill();
+            }
+        });
+    });
+}
+function getPackageVersion(name) {
+    let directory = dirname(fileURLToPath(import.meta.resolve(name)));
+    while (true) {
+        try {
+            const manifest = JSON.parse(readFileSync(join(directory, 'package.json'), 'utf8'));
+            if (manifest.name === name && manifest.version)
+                return manifest.version;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const parent = dirname(directory);
+        if (parent === directory)
+            break;
+        directory = parent;
+    }
+    throw new Error(`Could not resolve package version: ${name}`);
+}
+function appModule() {
+    return `import { createEmbedder } from '@lat.md/embed';
+import minilm from '@lat.md/embed-minilm-fp16';
+import express from 'express';
+import { createServerViewApp } from 'lat.md/server';
+const view = createServerViewApp({
+  app: express(),
+  manifestFile: new URL('./server-data/server.json', import.meta.url),
+  indexFile: new URL('./server-data/search.db', import.meta.url),
+  createSearchEngine: () => createEmbedder({ model: minilm }),
+});
+export const close = view.close;
+export default view.app;
+`;
+}
+function packageManifest(latVersion, serverVersion, runtimeVersions) {
+    return `${JSON.stringify({
+        name: 'lat-ui-server',
+        private: true,
+        type: 'module',
+        scripts: { start: 'lat-ui-server app.mjs' },
+        dependencies: {
+            '@lat.md/embed': runtimeVersions.embed,
+            '@lat.md/embed-minilm-fp16': runtimeVersions.model,
+            '../../vendor/lat.md-server/index.js': serverVersion,
+            express: runtimeVersions.express,
+            'lat.md': latVersion,
+        },
+    }, null, 2)}\n`;
+}
+/** Build immutable UI data plus the small portable Express search service. */
+export async function buildServerView(ctx, requestedOutput, options = {}, dependencies = defaultDependencies) {
+    const outputDir = resolve(ctx.projectRoot, requestedOutput);
+    const basePath = normalizeStaticViewBasePath(options.basePath ?? '/');
+    await validateViewBuildOutput(outputDir, ctx.projectRoot, 'Server', options.force);
+    await mkdir(dirname(outputDir), { recursive: true });
+    const stagingDir = await mkdtemp(join(dirname(outputDir), '.lat-server-staging-'));
+    try {
+        const publicDir = join(stagingDir, 'public');
+        const dataDir = join(stagingDir, 'server-data');
+        const staticResult = await dependencies.buildStaticView(ctx, publicDir, {
+            ...options,
+            basePath,
+            searchApi: `${basePath}api/search`,
+        });
+        const project = await dependencies.analyzeMarkdownProject(ctx.latDir, ctx.projectRoot, { executor: 'auto' });
+        await dependencies.buildSearchIndex(ctx.latDir, project, dataDir);
+        const sections = project.sections.map(({ children: _children, ...section }) => ({
+            ...section,
+            documentPath: toPosix(relative(ctx.latDir, resolve(ctx.projectRoot, section.filePath))),
+        }));
+        const manifest = {
+            version: SERVER_VIEW_SCHEMA_VERSION,
+            basePath,
+            sections,
+        };
+        await writeFile(join(dataDir, 'server.json'), `${JSON.stringify(manifest)}\n`);
+        await writeFile(join(stagingDir, 'app.mjs'), appModule());
+        await writeFile(join(stagingDir, 'package.json'), packageManifest(dependencies.getLocalVersion(), dependencies.getLatServerVersion(), {
+            embed: dependencies.getPackageVersion('@lat.md/embed'),
+            express: dependencies.getPackageVersion('express'),
+            model: dependencies.getPackageVersion('@lat.md/embed-minilm-fp16'),
+        }));
+        if (options.force) {
+            await rm(outputDir, { recursive: true, force: true });
+        }
+        await moveViewBuildOutput(stagingDir, outputDir);
+        return { ...staticResult, outputDir };
+    }
+    catch (error) {
+        await removeViewBuildStaging(stagingDir);
+        throw error;
+    }
+}

package/dist/src/view/server-deployment.d.ts

@@ -0,0 +1,31 @@
+import { type LatServerApp } from '../../vendor/lat.md-server/index.js';
+import type { Express } from 'express';
+import type { Section } from '@plebeiantech/lat.md-core/lattice-model';
+import type { CreateSearchEngine } from '../search/embedder.js';
+import type { ViewSearchResponse } from './protocol.js';
+export declare const SERVER_VIEW_SCHEMA_VERSION = 1;
+export type ServerViewSection = Omit<Section, 'children'> & {
+    documentPath: string;
+};
+export type ServerViewManifest = {
+    version: number;
+    basePath: string;
+    sections: ServerViewSection[];
+};
+export type ServerViewAppOptions = {
+    app: Express;
+    manifestFile: string | URL;
+    indexFile: string | URL;
+    createSearchEngine?: CreateSearchEngine;
+    search?: (query: string) => Promise<ViewSearchResponse>;
+};
+export type ServerViewApp = {
+    app: LatServerApp;
+    close: () => Promise<void>;
+};
+/**
+ * Create the portable Express application emitted by `lat ui build server`.
+ * Static assets are also mounted for ordinary Node hosts; platforms with a CDN
+ * can serve `public/` directly and forward only the search route to this app.
+ */
+export declare function createServerViewApp(options: ServerViewAppOptions): ServerViewApp;

package/dist/src/view/server-deployment.js

@@ -0,0 +1,123 @@
+import { INDEX_FILE } from '../search/db.js';
+import { chmod, copyFile, mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createLatServerApp } from '../../vendor/lat.md-server/index.js';
+import { createPreindexedViewSearch, } from './preindexed-search.js';
+export const SERVER_VIEW_SCHEMA_VERSION = 1;
+function searchRoute(basePath) {
+    return `${basePath === '/' ? '' : basePath.slice(0, -1)}/api/search`;
+}
+function sendJson(res, status, value, headOnly) {
+    const body = JSON.stringify(value);
+    res.statusCode = status;
+    res.setHeader('Cache-Control', 'no-store');
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.setHeader('Content-Length', Buffer.byteLength(body));
+    res.end(headOnly ? undefined : body);
+}
+function localPath(path) {
+    return resolve(typeof path === 'string' ? path : fileURLToPath(path));
+}
+async function readManifest(path) {
+    const manifest = JSON.parse(await readFile(path, 'utf8'));
+    if (manifest.version !== SERVER_VIEW_SCHEMA_VERSION ||
+        typeof manifest.basePath !== 'string' ||
+        !Array.isArray(manifest.sections)) {
+        throw new Error(`Unsupported Lat server build manifest: ${path}`);
+    }
+    return manifest;
+}
+async function prepareServerView(options, manifestFile, indexFile) {
+    const manifest = await readManifest(manifestFile);
+    let search = options.search;
+    let ownedSearch;
+    let runtimeDir;
+    if (!search) {
+        if (basename(indexFile) !== INDEX_FILE) {
+            throw new Error(`Server search index must be named ${INDEX_FILE}: ${indexFile}`);
+        }
+        const documentPaths = new Map();
+        const sections = manifest.sections.map(({ documentPath, ...section }) => {
+            documentPaths.set(section.id.toLowerCase(), documentPath);
+            return { ...section, children: [] };
+        });
+        const openSearch = (cacheDir) => createPreindexedViewSearch(dirname(indexFile), cacheDir, sections, documentPaths, undefined, options.createSearchEngine);
+        try {
+            ownedSearch = await openSearch(dirname(indexFile));
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'EROFS' && code !== 'EACCES')
+                throw error;
+            // Serverless bundles are immutable; locks and database sidecars need writes.
+            runtimeDir = await mkdtemp(join(tmpdir(), 'lat-server-search-'));
+            try {
+                await copyFile(indexFile, join(runtimeDir, INDEX_FILE));
+                await chmod(join(runtimeDir, INDEX_FILE), 0o600);
+                ownedSearch = await openSearch(runtimeDir);
+            }
+            catch (copyError) {
+                await rm(runtimeDir, { recursive: true, force: true });
+                throw copyError;
+            }
+        }
+        search = ownedSearch;
+    }
+    return {
+        manifest,
+        search,
+        close: async () => {
+            try {
+                await ownedSearch?.close();
+            }
+            finally {
+                if (runtimeDir)
+                    await rm(runtimeDir, { recursive: true, force: true });
+            }
+        },
+    };
+}
+/**
+ * Create the portable Express application emitted by `lat ui build server`.
+ * Static assets are also mounted for ordinary Node hosts; platforms with a CDN
+ * can serve `public/` directly and forward only the search route to this app.
+ */
+export function createServerViewApp(options) {
+    const manifestFile = localPath(options.manifestFile);
+    const publicDir = resolve(dirname(manifestFile), '..', 'public');
+    const prepared = prepareServerView(options, manifestFile, localPath(options.indexFile));
+    // Preparation starts before the first request; requests still receive its error.
+    void prepared.catch(() => { });
+    const app = createLatServerApp({
+        publicDir,
+        async handle(req, res, next) {
+            const { manifest, search } = await prepared;
+            const method = req.method ?? 'GET';
+            const headOnly = method === 'HEAD';
+            if (method !== 'GET' && !headOnly)
+                return next();
+            const url = new URL(req.url ?? '/', 'http://lat.local');
+            if (url.pathname !== searchRoute(manifest.basePath))
+                return next();
+            try {
+                const query = (url.searchParams.get('query') ?? '').trim();
+                if (query.length > 500) {
+                    sendJson(res, 400, { error: 'Search query is too long' }, headOnly);
+                    return;
+                }
+                sendJson(res, 200, await search(query), headOnly);
+            }
+            catch (error) {
+                next(error);
+            }
+        },
+    }, options.app);
+    return {
+        app,
+        close: async () => {
+            await (await prepared).close();
+        },
+    };
+}

package/dist/src/view/server-index-worker.d.ts

@@ -0,0 +1,6 @@
+import type { MarkdownProjectAnalysis } from '@plebeiantech/lat.md-core/project-analysis';
+export type ServerIndexRequest = {
+    latDir: string;
+    project: MarkdownProjectAnalysis;
+    cacheDir: string;
+};

package/dist/src/view/server-index-worker.js

@@ -0,0 +1,14 @@
+import { runIndex } from '../cli/search.js';
+process.once('message', async (request) => {
+    try {
+        await runIndex(request.latDir, undefined, request.project, {
+            cacheDir: request.cacheDir,
+        });
+        // Process exit releases native database handles before staging is renamed.
+        process.exit(0);
+    }
+    catch (error) {
+        console.error(error);
+        process.exit(1);
+    }
+});

package/dist/src/view/server.d.ts

@@ -1,5 +1,6 @@
 import { type Server } from 'node:http';
-import type { CmdContext } from '../context.js';
+import { type LatServerApp } from '../../vendor/lat.md-server/index.js';
+import { type CmdContext } from '@plebeiantech/lat.md-core/context';
 import { type ViewSearch } from './search.js';
 import { type ViewStore } from './store.js';
 export declare const DEFAULT_VIEW_PORT = 4242;
@@ -9,6 +10,11 @@ export type ViewServer = {
     url: string;
     close: () => Promise<void>;
 };
+export type ViewApp = {
+    app: LatServerApp;
+    store: ViewStore;
+    close: () => Promise<void>;
+};
 export type ViewServerOptions = {
     clientDir?: string;
     git?: boolean;
@@ -18,6 +24,9 @@ export type ViewServerOptions = {
     port?: number;
     search?: ViewSearch;
     watch?: boolean;
+    externalCa?: string | Buffer;
 };
-/** Start the read-only loopback server used by `lat ui`. */
+/** Create the portable Express application used by live Lat UI servers. */
+export declare function createViewApp(ctx: CmdContext, options?: ViewServerOptions): Promise<ViewApp>;
+/** Start the loopback server used by `lat ui`. */
 export declare function startViewServer(ctx: CmdContext, options?: ViewServerOptions): Promise<ViewServer>;