@oml/cli 0.14.1 → 0.14.3

package/src/commands/server/rest.ts

@@ -1,9 +1,11 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
+import * as http from 'node:http';
 import * as fs from 'node:fs/promises';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { createHash } from 'node:crypto';
+import { URL } from 'node:url';
 
 const DEFAULT_HOST = '127.0.0.1';
 
@@ -18,6 +20,21 @@ type Envelope<T> = {
     error?: string;
 };
 
+type ErrorEnvelope = {
+    error?: string | {
+        code?: string;
+        message?: string;
+        status?: number;
+        retryable?: boolean;
+    };
+};
+
+type HttpJsonResponse = {
+    status: number;
+    statusText: string;
+    body: string;
+};
+
 function workspaceHash(workspaceRoot: string): string {
     return createHash('sha256').update(path.resolve(workspaceRoot)).digest('hex');
 }
@@ -71,65 +88,135 @@ async function readRunningState(workspaceRoot = process.cwd()): Promise<ServerSt
     }
 }
 
-function createHeaders(token: string | undefined): Headers {
-    const headers = new Headers();
-    headers.set('content-type', 'application/json');
-    if (token && token.trim().length > 0) {
-        headers.set('authorization', `Bearer ${token.trim()}`);
-    }
-    return headers;
-}
-
 function ensureServerBaseUrl(state: ServerState | undefined): string {
     if (!state) {
-        throw new Error('start server first');
+        throw new Error("OML server is not running. Start it with 'oml start'.");
     }
     return `http://${DEFAULT_HOST}:${state.port}`;
 }
 
-async function parseJsonResponse<T>(response: Response): Promise<T> {
-    const text = await response.text();
+function parseJsonResponse<T>(status: number, statusText: string, text: string): T {
     if (!text.trim()) {
-        throw new Error(`Server returned HTTP ${response.status} ${response.statusText} with empty response body.`);
+        throw new Error(`Server returned HTTP ${status} ${statusText} with empty response body.`);
     }
     try {
         return JSON.parse(text) as T;
     } catch {
-        throw new Error(`Server returned HTTP ${response.status} ${response.statusText} with invalid JSON response.`);
+        throw new Error(`Server returned HTTP ${status} ${statusText} with invalid JSON response.`);
+    }
+}
+
+function requestJson(method: 'GET' | 'POST', url: string, body?: string): Promise<HttpJsonResponse> {
+    const target = new URL(url);
+    return new Promise<HttpJsonResponse>((resolve, reject) => {
+        const req = http.request({
+            protocol: target.protocol,
+            hostname: target.hostname,
+            port: target.port,
+            path: `${target.pathname}${target.search}`,
+            method,
+            headers: {
+                'content-type': 'application/json',
+                accept: 'application/json',
+            },
+        }, (res) => {
+            let payload = '';
+            res.setEncoding('utf-8');
+            res.on('data', (chunk: string) => {
+                payload += chunk;
+            });
+            res.on('end', () => {
+                resolve({
+                    status: res.statusCode ?? 0,
+                    statusText: res.statusMessage ?? '',
+                    body: payload,
+                });
+            });
+        });
+        req.once('error', reject);
+        if (body !== undefined) {
+            req.write(body, 'utf-8');
+        }
+        req.end();
+    });
+}
+
+function buildResponseLike(response: HttpJsonResponse): { ok: boolean; status: number } {
+    return {
+        ok: response.status >= 200 && response.status < 300,
+        status: response.status,
     }
 }
 
 export async function restGet<T>(route: string, authToken?: string): Promise<T> {
+    void authToken;
     const baseUrl = ensureServerBaseUrl(await readRunningState());
-    const response = await fetch(`${baseUrl}${route}`, {
-        method: 'GET',
-        headers: createHeaders(authToken),
-    });
-    const payload = await parseJsonResponse<T & { error?: string }>(response);
-    if (!response.ok) {
-        const message = (payload as { error?: string }).error;
-        throw new Error(message && message.trim().length > 0 ? message : `Server request failed: GET ${route} (${response.status}).`);
+    let response: HttpJsonResponse;
+    try {
+        response = await requestJson('GET', `${baseUrl}${route}`);
+    } catch {
+        throw new Error(`OML server is unreachable at ${baseUrl}. Start it with 'oml start' or check connectivity.`);
+    }
+    const responseLike = buildResponseLike(response);
+    const payload = parseJsonResponse<T & ErrorEnvelope>(response.status, response.statusText, response.body);
+    if (!responseLike.ok) {
+        const message = normalizeServerError(payload.error);
+        throw new Error(message ?? `Server request failed: GET ${route} (${responseLike.status}).`);
     }
     return payload;
 }
 
 export async function restPost<T>(route: string, body: Record<string, unknown>, authToken?: string): Promise<T> {
+    void authToken;
     const baseUrl = ensureServerBaseUrl(await readRunningState());
-    const response = await fetch(`${baseUrl}${route}`, {
-        method: 'POST',
-        headers: createHeaders(authToken),
-        body: JSON.stringify(body),
-    });
-    const payload = await parseJsonResponse<Envelope<T> & { error?: string }>(response);
-    if (!response.ok) {
-        const message = payload.error;
-        throw new Error(message && message.trim().length > 0 ? message : `Server request failed: POST ${route} (${response.status}).`);
+    let response: HttpJsonResponse;
+    try {
+        response = await requestJson('POST', `${baseUrl}${route}`, JSON.stringify(body));
+    } catch {
+        throw new Error(`OML server is unreachable at ${baseUrl}. Start it with 'oml start' or check connectivity.`);
+    }
+    const responseLike = buildResponseLike(response);
+    const payload = parseJsonResponse<Envelope<T> & ErrorEnvelope>(response.status, response.statusText, response.body);
+    if (!responseLike.ok) {
+        const message = normalizeServerError(payload.error);
+        throw new Error(message ?? `Server request failed: POST ${route} (${responseLike.status}).`);
     }
     if (payload.ok === false) {
-        throw new Error(payload.error?.trim() || `Server request failed: POST ${route}.`);
+        const message = normalizeServerError(payload.error);
+        throw new Error(message ?? `Server request failed: POST ${route}.`);
     }
     if (payload.result === undefined) {
         throw new Error(`Server request failed: POST ${route} did not return a result.`);
     }
     return payload.result;
 }
+
+function normalizeServerError(error: ErrorEnvelope['error']): string | undefined {
+    if (typeof error === 'string' && error.trim().length > 0) {
+        return error.trim();
+    }
+    if (error && typeof error === 'object') {
+        const code = typeof error.code === 'string' ? error.code.trim().toLowerCase() : '';
+        if (code === 'auth_required') {
+            return "OML server authentication is required. Sign in and restart the server with 'oml start'.";
+        }
+        if (code === 'entitlements_pending') {
+            return 'OML entitlements are still loading. Retry in a moment.';
+        }
+        if (code === 'entitlements_unavailable') {
+            return "OML entitlements are unavailable. Sign in again with 'oml login' and restart the server.";
+        }
+        if (code === 'not_entitled') {
+            const message = typeof error.message === 'string' ? error.message.trim() : '';
+            return message.length > 0 ? message : 'This command is not enabled for your account.';
+        }
+        const message = typeof error.message === 'string' ? error.message.trim() : '';
+        if (message.length > 0) {
+            return message;
+        }
+        if (code.length > 0) {
+            return code;
+        }
+    }
+    return undefined;
+}