@oml/cli 0.12.0 → 0.14.0

package/src/commands/server/actions.ts

@@ -0,0 +1,480 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import * as net from 'node:net';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+import { constants as FsConstants } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+import { spawn, execFile, type ChildProcess } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const DEFAULT_HOST = '127.0.0.1';
+const STARTUP_TIMEOUT_MS = 15_000;
+const SHUTDOWN_TIMEOUT_MS = 3000;
+const POLL_INTERVAL_MS = 100;
+const execFileAsync = promisify(execFile);
+
+type StartServerOptions = {
+    port?: number | string;
+    workspace?: string;
+    auth?: {
+        accessToken: string;
+    };
+};
+
+type ServerStatePaths = {
+    dir: string;
+    lockFile: string;
+    workspaceRoot: string;
+};
+
+type ServerLockState = {
+    pid: number;
+    port: number;
+    owner?: 'daemon' | 'extension';
+};
+
+function workspaceHash(workspaceRoot: string): string {
+    return createHash('sha256').update(path.resolve(workspaceRoot)).digest('hex');
+}
+
+function getServerStatePaths(workspace?: string): ServerStatePaths {
+    const workspaceRoot = path.resolve(workspace ?? process.cwd());
+    const dir = path.join(os.homedir(), '.oml', 'workspaces', workspaceHash(workspaceRoot));
+    return {
+        dir,
+        lockFile: path.join(dir, 'server.lock'),
+        workspaceRoot,
+    };
+}
+
+async function cleanupStateFile(paths: ServerStatePaths): Promise<void> {
+    await fs.rm(paths.lockFile, { force: true });
+}
+
+function parseServerLock(raw: string): ServerLockState | undefined {
+    try {
+        const parsed = JSON.parse(raw) as { pid?: unknown; port?: unknown; owner?: unknown };
+        const pid = Number(parsed.pid);
+        const port = Number(parsed.port);
+        if (!Number.isFinite(pid) || !Number.isFinite(port)) {
+            return undefined;
+        }
+        const pidInt = Math.trunc(pid);
+        const portInt = Math.trunc(port);
+        if (pidInt <= 0 || portInt <= 0 || portInt > 65535) {
+            return undefined;
+        }
+        const owner = parsed.owner === 'daemon' || parsed.owner === 'extension'
+            ? parsed.owner
+            : undefined;
+        return { pid: pidInt, port: portInt, owner };
+    } catch {
+        return undefined;
+    }
+}
+
+async function readServerLock(lockFile: string): Promise<ServerLockState | undefined> {
+    try {
+        const raw = (await fs.readFile(lockFile, 'utf-8')).trim();
+        if (!raw) {
+            return undefined;
+        }
+        return parseServerLock(raw);
+    } catch {
+        return undefined;
+    }
+}
+
+function isProcessAlive(pid: number): boolean {
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+function resolveServerMainScript(): string {
+    const require = createRequire(import.meta.url);
+    const serverPackageJson = require.resolve('@oml/server/package.json');
+    const serverPackageDir = path.dirname(serverPackageJson);
+    return path.join(serverPackageDir, 'out', 'cli.js');
+}
+
+function canReadFile(filePath: string): Promise<boolean> {
+    return fs.access(filePath, FsConstants.R_OK).then(
+        () => true,
+        () => false,
+    );
+}
+
+function waitForPort(host: string, port: number, timeoutMs: number): Promise<boolean> {
+    const deadline = Date.now() + timeoutMs;
+    return new Promise<boolean>((resolve) => {
+        const attempt = (): void => {
+            const socket = new net.Socket();
+            let settled = false;
+            const finish = (value: boolean): void => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                socket.destroy();
+                resolve(value);
+            };
+            socket.once('connect', () => finish(true));
+            socket.once('error', () => {
+                socket.destroy();
+                if (Date.now() >= deadline) {
+                    resolve(false);
+                    return;
+                }
+                setTimeout(attempt, POLL_INTERVAL_MS);
+            });
+            socket.setTimeout(POLL_INTERVAL_MS, () => {
+                socket.destroy();
+                if (Date.now() >= deadline) {
+                    resolve(false);
+                    return;
+                }
+                setTimeout(attempt, POLL_INTERVAL_MS);
+            });
+            socket.connect(port, host);
+        };
+        attempt();
+    });
+}
+
+function assertPortAvailable(host: string, port: number): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+        const server = net.createServer();
+        const cleanup = (): void => {
+            server.removeAllListeners();
+        };
+        server.once('error', (error: NodeJS.ErrnoException) => {
+            cleanup();
+            if (error.code === 'EADDRINUSE') {
+                reject(new Error(`Port ${port} is already in use on ${host}. Stop the existing service or choose a different port.`));
+                return;
+            }
+            reject(error);
+        });
+        server.listen(port, host, () => {
+            server.close((closeError) => {
+                cleanup();
+                if (closeError) {
+                    reject(closeError);
+                    return;
+                }
+                resolve();
+            });
+        });
+    });
+}
+
+async function waitForProcessExit(pid: number, timeoutMs: number): Promise<boolean> {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessAlive(pid)) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    }
+    return !isProcessAlive(pid);
+}
+
+function normalizeStartPort(value: number | string | undefined): number {
+    if (value === undefined) {
+        return 0;
+    }
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) {
+        throw new Error(`Invalid port '${value}'. Expected an integer between 1 and 65535.`);
+    }
+    const intPort = Math.trunc(numeric);
+    if (intPort < 0 || intPort > 65535) {
+        throw new Error(`Invalid port '${value}'. Expected an integer between 1 and 65535.`);
+    }
+    return intPort;
+}
+
+async function inspectListeningProcess(port: number): Promise<string> {
+    const args = ['-nP', `-iTCP:${port}`, '-sTCP:LISTEN'];
+    try {
+        const { stdout } = await execFileAsync('lsof', args);
+        return stdout.trim();
+    } 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 typeof failed?.stdout === 'string' ? failed.stdout.trim() : '';
+    }
+}
+
+function spawnServerProcess(
+    serverMainScript: string,
+    port: number,
+    detached: boolean,
+    stdio: 'ignore' | 'inherit',
+    options: {
+        workspace?: string;
+        auth?: { accessToken: string };
+    },
+): ChildProcess {
+    const args = [serverMainScript, `--port=${port}`];
+
+    if (options.workspace) {
+        args.push(`--workspace=${path.resolve(options.workspace)}`);
+    }
+    if (options.auth?.accessToken) {
+        args.push(`--token=${options.auth.accessToken}`);
+    }
+
+    return spawn(process.execPath, args, {
+        detached,
+        stdio: [stdio, stdio, stdio],
+    });
+}
+
+async function ensureNotAlreadyRunning(paths: ServerStatePaths): Promise<void> {
+    const state = await readServerLock(paths.lockFile);
+    if (!state) {
+        await cleanupStateFile(paths);
+        return;
+    }
+    if (isProcessAlive(state.pid)) {
+        throw new Error(`Server already running for workspace '${paths.workspaceRoot}' (pid ${state.pid} on port :${state.port}).`);
+    }
+    await cleanupStateFile(paths);
+}
+
+async function waitForServerLock(paths: ServerStatePaths, pid: number, timeoutMs: number): Promise<ServerLockState | undefined> {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const state = await readServerLock(paths.lockFile);
+        if (state && state.pid === pid) {
+            return state;
+        }
+        if (!isProcessAlive(pid)) {
+            return undefined;
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    }
+    return undefined;
+}
+
+export async function serverStartAction(portArg: number | string | undefined, options: StartServerOptions): Promise<void> {
+    if (portArg !== undefined && options.port !== undefined && String(portArg) !== String(options.port)) {
+        throw new Error(`Conflicting port values '${portArg}' and '${options.port}'. Use either the positional port or --port, not both.`);
+    }
+    const port = normalizeStartPort(options.port ?? portArg);
+    const serverMainScript = resolveServerMainScript();
+    const scriptExists = await canReadFile(serverMainScript);
+    if (!scriptExists) {
+        throw new Error(`Server entrypoint is missing: ${serverMainScript}. Build the workspace first.`);
+    }
+
+    const paths = getServerStatePaths(options.workspace);
+    await ensureNotAlreadyRunning(paths);
+    if (port > 0) {
+        await assertPortAvailable(DEFAULT_HOST, port);
+    }
+
+    await serverStartDetached(serverMainScript, port, paths, options);
+}
+
+async function serverStartDetached(
+    serverMainScript: string,
+    port: number,
+    paths: ServerStatePaths,
+    options: StartServerOptions
+): Promise<void> {
+    const child = spawnServerProcess(serverMainScript, port, true, 'ignore', {
+        workspace: options.workspace,
+        auth: options.auth,
+    });
+    if (!child.pid) {
+        throw new Error('Failed to launch server process.');
+    }
+    child.unref();
+
+    const state = await waitForServerLock(paths, child.pid, STARTUP_TIMEOUT_MS);
+    if (!state) {
+        if (isProcessAlive(child.pid)) {
+            process.kill(child.pid, 'SIGTERM');
+        }
+        throw new Error(`Server did not become ready within ${STARTUP_TIMEOUT_MS} ms.`);
+    }
+    const ready = await waitForPort(DEFAULT_HOST, state.port, STARTUP_TIMEOUT_MS);
+    if (!ready) {
+        if (isProcessAlive(child.pid)) {
+            process.kill(child.pid, 'SIGTERM');
+        }
+        throw new Error(`Server did not become reachable on ${DEFAULT_HOST}:${state.port} within ${STARTUP_TIMEOUT_MS} ms.`);
+    }
+
+    const endpoint = `http://${DEFAULT_HOST}:${state.port}`;
+    console.log(`OML server started on ${endpoint} (pid ${state.pid})`);
+    console.log("Use 'oml server stop' to stop the server");
+}
+
+export async function serverStopAction(): Promise<void> {
+    const paths = getServerStatePaths();
+    const state = await readServerLock(paths.lockFile);
+    if (!state) {
+        await cleanupStateFile(paths);
+        process.stdout.write('Server is not running.\n');
+        return;
+    }
+    if (!isProcessAlive(state.pid)) {
+        await cleanupStateFile(paths);
+        process.stdout.write('Server is not running.\n');
+        return;
+    }
+    const owner = state.owner ?? 'unknown';
+    if (owner !== 'daemon') {
+        process.stdout.write(`Server is running (pid ${state.pid}, port ${state.port}) and managed by ${owner}; not stopping.\n`);
+        return;
+    }
+
+    process.kill(state.pid, 'SIGTERM');
+    const exited = await waitForProcessExit(state.pid, SHUTDOWN_TIMEOUT_MS);
+    if (!exited) {
+        throw new Error(`Timed out waiting for server process ${state.pid} to stop.`);
+    }
+    await cleanupStateFile(paths);
+    process.stdout.write(`Server stopped (pid ${state.pid}).\n`);
+}
+
+export async function serverStatusAction(): Promise<void> {
+    const paths = getServerStatePaths();
+    const state = await readServerLock(paths.lockFile);
+    if (!state || !isProcessAlive(state.pid)) {
+        if (state) {
+            await cleanupStateFile(paths);
+        }
+        process.stdout.write('Server is not running.\n');
+        return;
+    }
+    const output = await inspectListeningProcess(state.port);
+    if (!output) {
+        process.stdout.write(`No listening process found on port ${state.port}.\n`);
+        return;
+    }
+    process.stdout.write(`${output}\n`);
+}
+
+export type RunServerOptions = {
+    port?: number | string;
+    workspace?: string;
+    auth: {
+        accessToken: string;
+        refreshToken: string;
+        expiresAtMs: number;
+        onRefresh: (newAccessToken: string, newRefreshToken: string, newExpiresAtMs: number) => Promise<void>;
+    };
+};
+
+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()) {
+        throw new Error(
+            'OML_PLATFORM_API_KEY is set but oml server run requires interactive authentication. ' +
+            'Use \'oml server start\' for non-interactive CI/CD mode with an API key.'
+        );
+    }
+
+    if (portArg !== undefined && options.port !== undefined && String(portArg) !== String(options.port)) {
+        throw new Error(`Conflicting port values '${portArg}' and '${options.port}'. Use either the positional port or --port, not both.`);
+    }
+    const port = normalizeStartPort(options.port ?? portArg);
+    const serverMainScript = resolveServerMainScript();
+    const scriptExists = await canReadFile(serverMainScript);
+    if (!scriptExists) {
+        throw new Error(`Server entrypoint is missing: ${serverMainScript}. Build the workspace first.`);
+    }
+
+    const paths = getServerStatePaths(options.workspace);
+    await ensureNotAlreadyRunning(paths);
+    if (port > 0) {
+        await assertPortAvailable(DEFAULT_HOST, port);
+    }
+
+    const args = [serverMainScript, `--port=${port}`];
+    if (options.workspace) {
+        args.push(`--workspace=${path.resolve(options.workspace)}`);
+    }
+    args.push(`--token=${options.auth.accessToken}`);
+
+    const child = spawn(process.execPath, args, {
+        detached: false,
+        stdio: ['pipe', 'inherit', 'inherit'],
+    });
+
+    if (!child.pid || !child.stdin) {
+        throw new Error('Failed to launch server process.');
+    }
+
+    const state = await waitForServerLock(paths, child.pid, STARTUP_TIMEOUT_MS);
+    if (!state) {
+        child.kill('SIGTERM');
+        throw new Error(`Server did not become ready within ${STARTUP_TIMEOUT_MS} ms.`);
+    }
+    const ready = await waitForPort(DEFAULT_HOST, state.port, STARTUP_TIMEOUT_MS);
+    if (!ready) {
+        child.kill('SIGTERM');
+        throw new Error(`Server did not become reachable on ${DEFAULT_HOST}:${state.port} within ${STARTUP_TIMEOUT_MS} ms.`);
+    }
+
+    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;
+    const REFRESH_INTERVAL_MS = 60 * 60 * 1000;
+    let currentRefreshToken = options.auth.refreshToken;
+    let currentExpiresAtMs = options.auth.expiresAtMs;
+
+    const refreshTimer = setInterval(async () => {
+        try {
+            const leeway = 5 * 60 * 1000;
+            if (Date.now() + leeway < currentExpiresAtMs) {
+                return;
+            }
+            const { refreshSupabaseAccessToken } = await import('@oml/platform');
+            const supabaseUrl = process.env.OML_SUPABASE_URL?.trim() ?? '';
+            const supabaseAnonKey = process.env.OML_SUPABASE_ANON_KEY?.trim() ?? '';
+            const refreshed = await refreshSupabaseAccessToken(supabaseUrl, supabaseAnonKey, currentRefreshToken);
+            currentRefreshToken = refreshed.refresh_token;
+            currentExpiresAtMs = Date.now() + refreshed.expires_in * 1000;
+            sendLspNotification(stdin, '$/tokenRefreshed', { accessToken: refreshed.access_token });
+            await options.auth.onRefresh(refreshed.access_token, refreshed.refresh_token, currentExpiresAtMs);
+        } catch {
+            // Refresh failure is non-fatal — server continues with cached token.
+        }
+    }, REFRESH_INTERVAL_MS);
+
+    await new Promise<void>((resolve) => {
+        const shutdown = (): void => {
+            clearInterval(refreshTimer);
+            child.kill('SIGTERM');
+            resolve();
+        };
+        process.once('SIGINT', shutdown);
+        process.once('SIGTERM', shutdown);
+        child.once('exit', () => {
+            clearInterval(refreshTimer);
+            resolve();
+        });
+    });
+
+    await cleanupStateFile(paths);
+}

package/src/commands/server/require.ts

@@ -0,0 +1,99 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import * as fs from 'node:fs/promises';
+import * as net from 'node:net';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { createHash } from 'node:crypto';
+
+const DEFAULT_HOST = '127.0.0.1';
+const CONNECT_TIMEOUT_MS = 400;
+const START_SERVER_HINT = "start server first (run 'oml server start')";
+
+type ServerState = {
+    pid: number;
+    port: number;
+};
+
+function workspaceHash(workspaceRoot: string): string {
+    return createHash('sha256').update(path.resolve(workspaceRoot)).digest('hex');
+}
+
+function serverLockFileForWorkspace(workspaceRoot: string): string {
+    return path.join(os.homedir(), '.oml', 'workspaces', workspaceHash(workspaceRoot), 'server.lock');
+}
+
+function parseServerState(raw: string): ServerState | undefined {
+    try {
+        const parsed = JSON.parse(raw) as { pid?: unknown; port?: unknown };
+        const pid = Number(parsed.pid);
+        const port = Number(parsed.port);
+        if (!Number.isFinite(pid) || !Number.isFinite(port)) {
+            return undefined;
+        }
+        const pidInt = Math.trunc(pid);
+        const portInt = Math.trunc(port);
+        if (pidInt <= 0 || portInt <= 0 || portInt > 65535) {
+            return undefined;
+        }
+        return { pid: pidInt, port: portInt };
+    } catch {
+        return undefined;
+    }
+}
+
+function isProcessAlive(pid: number): boolean {
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+function isPortReachable(host: string, port: number): Promise<boolean> {
+    return new Promise<boolean>((resolve) => {
+        const socket = new net.Socket();
+        let settled = false;
+        const finish = (value: boolean): void => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            socket.destroy();
+            resolve(value);
+        };
+        socket.once('connect', () => finish(true));
+        socket.once('error', () => finish(false));
+        socket.setTimeout(CONNECT_TIMEOUT_MS, () => finish(false));
+        socket.connect(port, host);
+    });
+}
+
+async function readRunningState(workspaceRoot = process.cwd()): Promise<ServerState | undefined> {
+    const lockFile = serverLockFileForWorkspace(path.resolve(workspaceRoot));
+    try {
+        const raw = (await fs.readFile(lockFile, 'utf-8')).trim();
+        if (!raw) {
+            return undefined;
+        }
+        const state = parseServerState(raw);
+        if (!state || !isProcessAlive(state.pid)) {
+            return undefined;
+        }
+        return state;
+    } catch {
+        return undefined;
+    }
+}
+
+export async function assertServerRunning(): Promise<void> {
+    const state = await readRunningState();
+    if (!state) {
+        throw new Error(START_SERVER_HINT);
+    }
+    const reachable = await isPortReachable(DEFAULT_HOST, state.port);
+    if (!reachable) {
+        throw new Error(START_SERVER_HINT);
+    }
+}