@oml/cli 0.14.16 → 0.15.0

package/src/commands/server/actions.ts

@@ -17,12 +17,19 @@ const SHUTDOWN_TIMEOUT_MS = 3000;
 const POLL_INTERVAL_MS = 100;
 const execFileAsync = promisify(execFile);
 
+type EntitlementCache = {
+    expiry: number;
+    featureIds: string[];
+    token?: string;
+};
+
 type StartServerOptions = {
     port?: number | string;
     workspace?: string;
     auth?: {
         accessToken: string;
     };
+    entitlementCache?: EntitlementCache;
 };
 
 type ServerStatePaths = {
@@ -34,7 +41,7 @@ type ServerStatePaths = {
 type ServerLockState = {
     pid: number;
     port: number;
-    owner?: 'daemon' | 'extension';
+    owner?: 'cli' | 'extension';
     workspaceRoot?: string;
 };
 
@@ -63,6 +70,7 @@ function getServerStatePaths(workspace?: string): ServerStatePaths {
 
 async function cleanupStateFile(paths: ServerStatePaths): Promise<void> {
     await fs.rm(paths.lockFile, { force: true });
+    await fs.rm(paths.dir, { recursive: true, force: true });
 }
 
 function parseServerLock(raw: string): ServerLockState | undefined {
@@ -78,7 +86,7 @@ function parseServerLock(raw: string): ServerLockState | undefined {
         if (pidInt <= 0 || portInt <= 0 || portInt > 65535) {
             return undefined;
         }
-        const owner = parsed.owner === 'daemon' || parsed.owner === 'extension'
+        const owner = parsed.owner === 'cli' || parsed.owner === 'extension'
             ? parsed.owner
             : undefined;
         const workspaceRoot = typeof parsed.workspaceRoot === 'string' && parsed.workspaceRoot.trim().length > 0
@@ -105,7 +113,7 @@ async function readServerLock(lockFile: string): Promise<ServerLockState | undef
 type RunningServer = {
     pid: number;
     port: number;
-    owner: 'daemon' | 'extension' | 'unknown';
+    owner: 'cli' | 'extension' | 'unknown';
     workspaceRoot?: string;
     lockFile: string;
 };
@@ -128,6 +136,7 @@ async function listRunningServers(): Promise<RunningServer[]> {
         }
         if (!isProcessAlive(state.pid)) {
             await fs.rm(lockFile, { force: true });
+            await fs.rm(path.dirname(lockFile), { recursive: true, force: true });
             continue;
         }
         servers.push({
@@ -257,7 +266,7 @@ function normalizeStartPort(value: number | string | undefined): number {
     return intPort;
 }
 
-async function inspectListeningProcess(port: number): Promise<string> {
+async function inspectListeningProcess(port: number): Promise<string | undefined> {
     const args = ['-nP', `-iTCP:${port}`, '-sTCP:LISTEN'];
     try {
         const { stdout } = await execFileAsync('lsof', args);
@@ -265,7 +274,7 @@ async function inspectListeningProcess(port: number): Promise<string> {
     } catch (error) {
         const failed = error as NodeJS.ErrnoException & { stdout?: string };
         if (failed?.code === 'ENOENT') {
-            throw new Error("Cannot inspect ports because 'lsof' is not installed or not on PATH.");
+            return undefined;
         }
         return typeof failed?.stdout === 'string' ? failed.stdout.trim() : '';
     }
@@ -279,6 +288,7 @@ function spawnServerProcess(
     options: {
         workspace?: string;
         auth?: { accessToken: string };
+        entitlementCache?: EntitlementCache;
     },
 ): ChildProcess {
     const args = [serverMainScript, `--port=${port}`];
@@ -289,6 +299,13 @@ function spawnServerProcess(
     if (options.auth?.accessToken) {
         args.push(`--token=${options.auth.accessToken}`);
     }
+    if (options.entitlementCache) {
+        args.push(`--entitlement-expiry=${options.entitlementCache.expiry}`);
+        args.push(`--entitlement-features=${JSON.stringify(options.entitlementCache.featureIds)}`);
+        if (options.entitlementCache.token) {
+            args.push(`--entitlement-token=${options.entitlementCache.token}`);
+        }
+    }
 
     return spawn(process.execPath, args, {
         detached,
@@ -352,6 +369,7 @@ async function serverStartDetached(
     const child = spawnServerProcess(serverMainScript, port, true, 'ignore', {
         workspace: options.workspace,
         auth: options.auth,
+        entitlementCache: options.entitlementCache,
     });
     if (!child.pid) {
         throw new Error('Failed to launch server process.');
@@ -392,7 +410,7 @@ export async function serverStopAction(): Promise<void> {
         return;
     }
     const owner = state.owner ?? 'unknown';
-    if (owner !== 'daemon') {
+    if (owner !== 'cli') {
         process.stdout.write(`Server is running (pid ${state.pid}, port ${state.port}) and managed by ${owner}; not stopping.\n`);
         return;
     }
@@ -417,6 +435,11 @@ export async function serverStatusAction(): Promise<void> {
         return;
     }
     const output = await inspectListeningProcess(state.port);
+    if (output === undefined) {
+        const owner = state.owner ?? 'unknown';
+        process.stdout.write(`Server is running on http://${DEFAULT_HOST}:${state.port} (pid ${state.pid}, owner ${owner}).\n`);
+        return;
+    }
     if (!output) {
         process.stdout.write(`No listening process found on port ${state.port}.\n`);
         return;
@@ -444,13 +467,10 @@ export type RunServerOptions = {
     auth: {
         accessToken: string;
     };
+    entitlementCache?: EntitlementCache;
+    deviceId?: string;
 };
 
-function sendLspNotification(childStdin: NodeJS.WritableStream, method: string, params: unknown): void {
-    const message = JSON.stringify({ jsonrpc: '2.0', method, params });
-    const header = `Content-Length: ${Buffer.byteLength(message, 'utf-8')}\r\n\r\n`;
-    childStdin.write(header + message, 'utf-8');
-}
 
 export async function serverRunAction(portArg: number | string | undefined, options: RunServerOptions): Promise<void> {
     if (process.env.OML_PLATFORM_API_KEY?.trim()) {
@@ -481,13 +501,23 @@ export async function serverRunAction(portArg: number | string | undefined, opti
         args.push(`--workspace=${path.resolve(options.workspace)}`);
     }
     args.push(`--token=${options.auth.accessToken}`);
+    if (options.entitlementCache) {
+        args.push(`--entitlement-expiry=${options.entitlementCache.expiry}`);
+        args.push(`--entitlement-features=${JSON.stringify(options.entitlementCache.featureIds)}`);
+        if (options.entitlementCache.token) {
+            args.push(`--entitlement-token=${options.entitlementCache.token}`);
+        }
+    }
+    if (options.deviceId) {
+        args.push(`--device-id=${options.deviceId}`);
+    }
 
     const child = spawn(process.execPath, args, {
         detached: false,
-        stdio: ['pipe', 'inherit', 'inherit'],
+        stdio: ['ignore', 'inherit', 'inherit', 'ipc'],
     });
 
-    if (!child.pid || !child.stdin) {
+    if (!child.pid) {
         throw new Error('Failed to launch server process.');
     }
 
@@ -505,7 +535,17 @@ export async function serverRunAction(portArg: number | string | undefined, opti
     process.stdout.write(`OML server running on http://${DEFAULT_HOST}:${state.port} (pid ${state.pid})\n`);
     process.stdout.write('Press Ctrl-C to stop.\n');
 
-    const stdin = child.stdin;
+    child.on('message', (msg: unknown) => {
+        if (msg && typeof msg === 'object' && (msg as Record<string, unknown>).type === 'entitlementsCached') {
+            const { expiry, featureIds, entitlementsToken } = msg as { expiry?: unknown; featureIds?: unknown; entitlementsToken?: unknown };
+            const expiryNum = Number(expiry);
+            const token = typeof entitlementsToken === 'string' ? entitlementsToken : undefined;
+            if (Number.isFinite(expiryNum) && Array.isArray(featureIds) && featureIds.every((x) => typeof x === 'string')) {
+                void options.authService.saveEntitlementCache(expiryNum, featureIds as string[], token);
+            }
+        }
+    });
+
     const REFRESH_INTERVAL_MS = 60 * 60 * 1000;
     const REFRESH_RETRY_BASE_MS = 15_000;
     const REFRESH_RETRY_MAX_MS = 5 * 60 * 1000;
@@ -533,7 +573,7 @@ export async function serverRunAction(portArg: number | string | undefined, opti
             const snapshot = await options.authService.getServerAuthSnapshot();
             if (snapshot.accessToken !== currentAccessToken) {
                 currentAccessToken = snapshot.accessToken;
-                sendLspNotification(stdin, '$/tokenRefreshed', { accessToken: snapshot.accessToken });
+                child.send({ type: 'tokenRefreshed', accessToken: snapshot.accessToken });
             }
             refreshFailureCount = 0;
             scheduleRefresh(REFRESH_INTERVAL_MS);

package/src/commands/validate.ts

@@ -31,7 +31,7 @@ export const validateAction = async (opts: ValidateOptions): Promise<void> => {
     }>('/v0/validate', {}, opts.authToken);
 
     if (result.filesChecked === 0) {
-        console.log(chalk.yellow('No markdown/table-editor targets found in server workspace.'));
+        console.log(chalk.yellow('No SHACL validation targets found in server workspace.'));
         return;
     }
     printLintDiagnostics({
@@ -77,16 +77,18 @@ export const validateAction = async (opts: ValidateOptions): Promise<void> => {
     if (result.errors > 0) {
         const failingItems = Number(result.failingItems ?? 0);
         if (failingItems > 0) {
-            failCli(chalk.red(`validate: ${result.filesChecked} table-editor block(s) scanned [${formatDuration(validateElapsedMs)}]; ${failingItems} failing block(s), ${result.errors} error(s), ${result.warnings} warning(s)`));
+            failCli(chalk.red(`validate: ${result.filesChecked} SHACL target(s) scanned [${formatDuration(validateElapsedMs)}]; ${failingItems} failing block(s), ${result.errors} error(s), ${result.warnings} warning(s)`));
         }
-        failCli(chalk.red(`validate: ${result.filesChecked} item(s) checked with ${result.errors} error(s) and ${result.warnings} warning(s). [${formatDuration(validateElapsedMs)}]`));
+        failCli(chalk.red(`validate: ${result.filesChecked} SHACL target(s) checked with ${result.errors} error(s) and ${result.warnings} warning(s). [${formatDuration(validateElapsedMs)}]`));
     }
     if (result.warnings > 0) {
         const failingItems = Number(result.failingItems ?? 0);
         if (failingItems > 0) {
-            failCli(chalk.yellow(`validate: ${result.filesChecked} table-editor block(s) scanned [${formatDuration(validateElapsedMs)}]; ${failingItems} failing block(s), ${result.errors} error(s), ${result.warnings} warning(s)`));
+            console.warn(chalk.yellow(`validate: ${result.filesChecked} SHACL target(s) scanned [${formatDuration(validateElapsedMs)}]; ${failingItems} failing block(s), ${result.errors} error(s), ${result.warnings} warning(s)`));
+        } else {
+            console.warn(chalk.yellow(`validate: ${result.filesChecked} SHACL target(s) checked with ${result.warnings} warning(s). [${formatDuration(validateElapsedMs)}]`));
         }
-        failCli(chalk.yellow(`validate: ${result.filesChecked} item(s) checked with ${result.warnings} warning(s). [${formatDuration(validateElapsedMs)}]`));
+        return;
     }
-    console.log(chalk.green(`validate: ${result.filesChecked} table-editor block(s) scanned [${formatDuration(validateElapsedMs)}]`));
+    console.log(chalk.green(`validate: ${result.filesChecked} SHACL target(s) scanned [${formatDuration(validateElapsedMs)}]`));
 };