@oml/cli 0.9.0 → 0.11.0

package/src/commands/render.ts

@@ -15,15 +15,16 @@ import {
     type MdBlockKind,
     type MdExecutableBlock
 } from '@oml/markdown';
+import { runWithIriLabelSnapshot } from '@oml/markdown/renderers';
 import { STATIC_MARKDOWN_RUNTIME_BUNDLE_FILE, STATIC_MARKDOWN_RUNTIME_CSS } from '@oml/markdown/static';
 import { normalizeFormatExtension } from '../backend/reasoned-output.js';
 import { createBackend } from '../backend/create-backend.js';
 import type { CliBackend } from '../backend/backend-types.js';
+import { failCli } from '../cli-error.js';
 import { formatDuration } from '../util.js';
 import type { ReasonOptions } from './reason.js';
 import { reasonAction } from './reason.js';
 import { resolveCompileOutputRoot, resolveCompileWorkspaceRoot } from './compile.js';
-const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
 const markdownRuntime = new MarkdownPreviewRuntime(new MarkdownHandlerRegistry());
 const SUPPORTED_MD_BLOCK_KINDS = new Set<MdBlockKind>([
     'table',
@@ -84,18 +85,15 @@ export const renderAction = async (
         const output = path.resolve(opts.web);
         const workspaceStat = await fs.stat(workspaceRoot).catch(() => undefined);
         if (!workspaceStat || !workspaceStat.isDirectory()) {
-            console.error(chalk.red(`Workspace folder does not exist: ${workspaceRoot}`));
-            process.exit(1);
+            failCli(chalk.red(`Workspace folder does not exist: ${workspaceRoot}`));
         }
         const markdownStat = await fs.stat(markdownRoot).catch(() => undefined);
         if (!markdownStat || !markdownStat.isDirectory()) {
-            console.error(chalk.red(`Markdown folder does not exist: ${markdownRoot}`));
-            process.exit(1);
+            failCli(chalk.red(`Markdown folder does not exist: ${markdownRoot}`));
         }
 
         if (isSameOrDescendant(markdownRoot, output)) {
-            console.error(chalk.red('Web output folder cannot be inside the markdown folder.'));
-            process.exit(1);
+            failCli(chalk.red('Web output folder cannot be inside the markdown folder.'));
         }
 
         if (opts.clean) {
@@ -108,6 +106,7 @@ export const renderAction = async (
         const templateCatalog = buildTemplateCatalog(templateFiles);
         const explicitContextModelUri = resolveModelUriOption(opts.context, workspaceRoot);
         const templateGenerationEnabled = explicitContextModelUri !== undefined;
+        const memberLabelSnapshot = await backend.getWorkspaceMemberLabelSnapshot(workspaceRoot);
         const wikiPageIndex = buildWikiPageIndex(renderableMarkdownFiles, markdownRoot, output);
         const generatedInstancePages = new Set<string>();
         const instancePageByIri = new Map<string, string>();
@@ -129,11 +128,11 @@ export const renderAction = async (
                 staticAssets.stylesheetFile,
                 templateGenerationEnabled,
                 explicitContextModelUri,
+                memberLabelSnapshot,
                 wikiPageIndex,
                 templateCatalog,
                 generatedInstancePages,
-                instancePageByIri
-                ,
+                instancePageByIri,
                 attemptedInstanceIris
             );
             const referencedWorkspaceAssets = rendered.workspaceAssets;
@@ -292,6 +291,7 @@ async function renderMarkdownFile(
     stylesheetFile: string,
     templateGenerationEnabled: boolean,
     defaultContextModelUri: string | undefined,
+    memberLabelSnapshot: Record<string, string>,
     wikiPageIndex: ReadonlyMap<string, string>,
     templateCatalog: TemplateCatalog,
     generatedInstancePages: Set<string>,
@@ -302,7 +302,9 @@ async function renderMarkdownFile(
     forcedModelUri?: string
 ): Promise<{ workspaceAssets: Set<string>; blockArtifactFiles: number }> {
     const markdown = explicitMarkdown ?? await fs.readFile(inputFile, 'utf-8');
-    const prepared = markdownRuntime.prepare(markdown);
+    const inlineContextUri = extractLeadingFrontMatter(markdown)?.contextUri;
+    const modelUri = forcedModelUri ?? resolveContextModelUri(inputFile, inlineContextUri, workspaceRoot) ?? defaultContextModelUri;
+    const prepared = runWithIriLabelSnapshot(memberLabelSnapshot, () => markdownRuntime.prepare(markdown));
     const rewriteResult = rewriteRenderedLinks(prepared.renderedHtml, {
         workspaceRoot,
         inputRoot,
@@ -312,7 +314,6 @@ async function renderMarkdownFile(
     });
     const executableBlocks = toExecutableBlocks(prepared.codeBlocks);
     const optionsByBlockId = new Map(prepared.codeBlocks.map((block) => [block.id, block.options] as const));
-    const modelUri = forcedModelUri ?? resolveContextModelUri(inputFile, prepared.contextUri, workspaceRoot) ?? defaultContextModelUri;
     const blockResults = executableBlocks.length === 0
         ? []
         : (await backend.executeMarkdownBlocks({
@@ -344,6 +345,7 @@ async function renderMarkdownFile(
             stylesheetFile,
             templateGenerationEnabled,
             modelUri,
+            memberLabelSnapshot,
             pageWikilinkIris,
             renderedBlockResults,
             wikiPageIndex,
@@ -368,7 +370,8 @@ async function renderMarkdownFile(
         blockRewriteResult.results,
         wikiLinkHrefByKey,
         { ...resolvedInstanceLinks, ...iriAliasHrefByIri },
-        templateGenerationEnabled && Boolean(modelUri)
+        templateGenerationEnabled && Boolean(modelUri),
+        memberLabelSnapshot
     );
     await fs.mkdir(path.dirname(outputFile), { recursive: true });
     await fs.writeFile(outputFile, html, 'utf-8');
@@ -445,8 +448,8 @@ async function writeStaticAssets(outputRoot: string): Promise<{
     const mergedStylesheet = `${sourceStylesheet}\n\n${STATIC_MARKDOWN_RUNTIME_CSS}\n`;
     const runtimeVersion = createHash('sha1').update(runtimeBundle).digest('hex').slice(0, 12);
     const stylesheetVersion = createHash('sha1').update(mergedStylesheet).digest('hex').slice(0, 12);
-    const runtimeFile = path.join(outputRoot, '_oml', `markdown-static-${runtimeVersion}.js`);
-    const stylesheetFile = path.join(outputRoot, '_oml', `markdown-webview-${stylesheetVersion}.css`);
+    const runtimeFile = path.join(outputRoot, 'assets', `markdown-static-${runtimeVersion}.js`);
+    const stylesheetFile = path.join(outputRoot, 'assets', `markdown-webview-${stylesheetVersion}.css`);
     await fs.mkdir(path.dirname(runtimeFile), { recursive: true });
     await fs.writeFile(runtimeFile, runtimeBundle, 'utf-8');
     await fs.writeFile(stylesheetFile, mergedStylesheet, 'utf-8');
@@ -468,18 +471,17 @@ async function loadStaticRuntimeBundle(): Promise<string> {
 }
 
 async function loadCodeBlockStylesheet(): Promise<string> {
-    const candidates = [
-        path.resolve(__dirname, '..', '..', '..', 'extension', 'src', 'webview', 'markdown-webview.css'),
-        path.resolve(__dirname, '..', '..', '..', 'extension', 'out', 'webview', 'markdown-webview.css'),
-    ];
-    for (const candidate of candidates) {
-        try {
-            return await fs.readFile(candidate, 'utf-8');
-        } catch {
-            // Try next candidate.
-        }
+    const require = createRequire(import.meta.url);
+    const staticEntry = require.resolve('@oml/markdown/static');
+    const stylesheetPath = path.resolve(path.dirname(staticEntry), '..', '..', 'src', 'static', 'markdown-webview.css');
+    try {
+        return await fs.readFile(stylesheetPath, 'utf-8');
+    } catch {
+        throw new Error(
+            `Unable to load markdown webview stylesheet at '${stylesheetPath}'. `
+            + 'The installed @oml/markdown package is missing a required static asset.'
+        );
     }
-    return '';
 }
 
 async function writeBlockArtifacts(outputFile: string, results: ReadonlyArray<RenderedBlockResult>): Promise<{
@@ -880,6 +882,7 @@ async function generateInstanceTemplatePages(
     stylesheetFile: string,
     templateGenerationEnabled: boolean,
     queryContextModelUri: string,
+    memberLabelSnapshot: Record<string, string>,
     pageWikilinkIris: ReadonlySet<string>,
     results: ReadonlyArray<RenderedBlockResult>,
     wikiPageIndex: ReadonlyMap<string, string>,
@@ -932,6 +935,7 @@ async function generateInstanceTemplatePages(
             stylesheetFile,
             templateGenerationEnabled,
             queryContextModelUri,
+            memberLabelSnapshot,
             wikiPageIndex,
             templateCatalog,
             generatedInstancePages,
@@ -960,7 +964,8 @@ function wrapHtml(
     blockResults: ReadonlyArray<RenderedBlockResult>,
     wikiLinkHrefByKey: Record<string, string>,
     iriAliasHrefByIri: Record<string, string>,
-    linkingEnabled: boolean
+    linkingEnabled: boolean,
+    memberLabelSnapshot?: Record<string, string>
 ): string {
     const escapedManifest = escapeJsonForScript(JSON.stringify(blockManifest));
     const inlineResults = Object.fromEntries(blockResults.map((result) => [result.blockId, result]));
@@ -968,6 +973,7 @@ function wrapHtml(
     const escapedWikiIndex = escapeJsonForScript(JSON.stringify(wikiLinkHrefByKey));
     const escapedIriAliasIndex = escapeJsonForScript(JSON.stringify(iriAliasHrefByIri));
     const escapedLinkingConfig = escapeJsonForScript(JSON.stringify({ linkingEnabled }));
+    const escapedMemberLabels = escapeJsonForScript(JSON.stringify(memberLabelSnapshot ?? {}));
     return `<!doctype html>
 <html lang="en">
 <head>
@@ -983,6 +989,7 @@ ${content}
 <script id="oml-md-wikilink-index" type="application/json">${escapedWikiIndex}</script>
 <script id="oml-md-wikilink-iri-aliases" type="application/json">${escapedIriAliasIndex}</script>
 <script id="oml-md-wikilink-config" type="application/json">${escapedLinkingConfig}</script>
+<script id="oml-md-member-labels" type="application/json">${escapedMemberLabels}</script>
 <script src="${escapeAttribute(runtimeScriptPath)}"></script>
 </body>
 </html>

package/src/commands/validate.ts

@@ -10,6 +10,7 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import * as url from 'node:url';
 import { loadPreparedDatasetFromOutput, normalizeFormatExtension } from '../backend/reasoned-output.js';
+import { failCli } from '../cli-error.js';
 import { formatDuration } from '../util.js';
 import type { ReasonOptions } from './reason.js';
 import { reasonAction } from './reason.js';
@@ -40,8 +41,7 @@ export const validateAction = async (opts: ValidateOptions): Promise<void> => {
 
     const markdownStat = await fs.stat(markdownRoot).catch(() => undefined);
     if (!markdownStat?.isDirectory()) {
-        console.error(chalk.red(`Markdown folder does not exist: ${markdownRoot}`));
-        process.exit(1);
+        failCli(chalk.red(`Markdown folder does not exist: ${markdownRoot}`));
     }
 
     if (!opts.only) {
@@ -98,7 +98,7 @@ export const validateAction = async (opts: ValidateOptions): Promise<void> => {
 
     reportValidationResults(results, workspaceRoot, markdownRoot, validationStartedAt);
     if (results.some((result) => result.error || result.issues.length > 0 || !result.conforms)) {
-        process.exit(1);
+        failCli('');
     }
 };
 

package/src/main.ts

@@ -1,5 +1,7 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
-import { runCli } from './cli.js';
+import { reportCliError, runCli } from './cli.js';
 
-void runCli();
+void runCli().catch((error) => {
+    process.exitCode = reportCliError(error);
+});

package/src/platform.ts

@@ -8,14 +8,16 @@
  * commands to execute. No whitelist or other fallback is used.
  */
 
-import { OmlClient, FileStorageAdapter } from '@oml/platform';
+import { OmlClient, FileStorageAdapter, installNodeShutdownHandlers } from '@oml/platform';
 import type { OmlClientConfig } from '@oml/platform';
+import type { NodeShutdownHandle } from '@oml/platform';
 import chalk from 'chalk';
 import { DEFAULT_API_BASE_URL } from './platform-constants.js';
 import { OmlCliAuthService } from './auth.js';
 const API_BASE_URL_ENV = 'OML_PLATFORM_API_URL';
 
 let client: OmlClient | null = null;
+let shutdownHandle: NodeShutdownHandle | null = null;
 
 export type CommandInvocationTracker = ReturnType<OmlClient['trackInvocation']>;
 
@@ -30,6 +32,8 @@ export async function initializePlatform(
     authService: OmlCliAuthService,
     apiBaseUrl = DEFAULT_API_BASE_URL
 ): Promise<void> {
+    await disposePlatform();
+
     const key = process.env.OML_PLATFORM_API_KEY;
     const resolvedApiBaseUrl = process.env[API_BASE_URL_ENV]?.trim() || apiBaseUrl;
 
@@ -66,6 +70,7 @@ export async function initializePlatform(
         throw new Error(`OML CLI could not connect to the authorization service. ${toGenericPlatformErrorMessage(error)}`);
     }
     client = platformClient;
+    shutdownHandle = installNodeShutdownHandlers(platformClient);
 }
 
 /**
@@ -73,6 +78,10 @@ export async function initializePlatform(
  * and ends the session. Call at the end of CLI execution.
  */
 export async function disposePlatform(): Promise<void> {
+    if (shutdownHandle) {
+        shutdownHandle.dispose();
+        shutdownHandle = null;
+    }
     if (client) {
         await client.dispose();
         client = null;

package/src/util.ts

@@ -5,17 +5,16 @@ import chalk from 'chalk';
 import * as path from 'node:path';
 import * as fs from 'node:fs';
 import { URI } from 'langium';
+import { failCli } from './cli-error.js';
 
 export async function extractDocument(fileName: string, services: LangiumCoreServices, workspaceRoot?: string): Promise<LangiumDocument> {
     const extensions = services.LanguageMetaData.fileExtensions;
     if (!extensions.includes(path.extname(fileName))) {
-        console.error(chalk.yellow(`Please choose a file with one of these extensions: ${extensions}.`));
-        process.exit(1);
+        failCli(chalk.yellow(`Please choose a file with one of these extensions: ${extensions}.`));
     }
 
     if (!fs.existsSync(fileName)) {
-        console.error(chalk.red(`File ${fileName} does not exist.`));
-        process.exit(1);
+        failCli(chalk.red(`File ${fileName} does not exist.`));
     }
 
     if (workspaceRoot) {
@@ -31,13 +30,13 @@ export async function extractDocument(fileName: string, services: LangiumCoreSer
     const diagnostics = document.diagnostics ?? [];
     const validationErrors = diagnostics.filter(e => e.severity === 1);
     if (validationErrors.length > 0) {
-        console.error(chalk.red(`There are validation errors in ${path.resolve(fileName)}:`));
+        let errorMessage = chalk.red(`There are validation errors in ${path.resolve(fileName)}:`);
         for (const validationError of validationErrors) {
-            console.error(chalk.red(
+            errorMessage += `\n${chalk.red(
                 `line ${validationError.range.start.line + 1}: ${validationError.message} [${document.textDocument.getText(validationError.range)}]`
-            ));
+            )}`;
         }
-        process.exit(1);
+        failCli(errorMessage);
     }
 
     const validationWarnings = diagnostics.filter(e => e.severity === 2);