@oml/cli 0.14.2 → 0.14.3

package/src/cli.ts

@@ -6,17 +6,15 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import * as url from 'node:url';
 import { OmlCliAuthService } from './auth/auth.js';
-import { exchangeApiToken } from '@oml/platform';
-import { DEFAULT_API_BASE_URL } from './auth/constants.js';
 import { exportAction } from './commands/export.js';
 import { lintAction } from './commands/lint.js';
 import { renderAction } from './commands/render.js';
-import { serverStartAction, serverRunAction, serverStatusAction, serverStopAction } from './commands/server/actions.js';
+import { serverStartAction, serverRunAction, serverStatusAction, serverStopAction, serverListAction } from './commands/server/actions.js';
 import { assertServerRunning } from './commands/server/require.js';
 import { notifyIfCliUpdateAvailable } from './update.js';
 import { validateAction } from './commands/validate.js';
 import { CliExitError } from './cli-error.js';
-import { initializePlatform, disposePlatform, trackCommand } from './auth/platform.js';
+import { trackCommand } from './auth/platform.js';
 
 const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
 let debugEnabled = false;
@@ -71,32 +69,70 @@ export async function runCli(argv: string[] = process.argv): Promise<void> {
 
     program
         .command('login')
-        .description('sign in with GitHub for CLI authorization')
+        .description('creates a sign-in session with OAuth for CLI')
         .action(async () => {
             await authService.login({});
         });
 
     program
         .command('logout')
-        .description('remove the local sign-in session')
+        .description('remove the CLI OAuth sign-in session')
         .action(async () => {
             await authService.logout();
         });
 
     program
         .command('whoami')
-        .description('print the current sign-in session')
+        .description('print the current CLI OAuth sign-in session (or api key account)')
         .action(async () => {
             await authService.whoami();
         });
 
+    program
+        .command('start [port]')
+        .option('-p, --port <port>', 'bind port (default: auto-select free port)')
+        .option('-w, --workspace <workspace>', 'workspace root used by REST facade initialize (default: cwd)')
+        .description('start an OML server')
+        .action(async (port: string | undefined, options: { port?: string; workspace?: string }) => {
+            if (process.env.OML_PLATFORM_API_KEY?.trim()) {
+                await serverStartAction(port, { ...options, auth: await resolveServerStartAuth() });
+                return;
+            }
+            await serverRunAction(port, {
+                ...options,
+                authService,
+                auth: await resolveServerRunAuth(authService),
+            });
+        });
+
+    program
+        .command('stop')
+        .description('stop the OML server')
+        .action(async () => {
+            await serverStopAction();
+        });
+
+    program
+        .command('status')
+        .description('print OML server status')
+        .action(async () => {
+            await serverStatusAction();
+        });
+
+    program
+        .command('list')
+        .description('show all actively running servers')
+        .action(async () => {
+            await serverListAction();
+        });
+
     program
         .command('lint')
         .description('lints OML files and prints any syntax or validation errors')
         .action(async (...args: unknown[]) => {
             const done = trackCommand('oml-lint');
             try {
-                const authToken = await resolveServerRequestToken(authService);
+                const authToken = resolveServerRequestToken();
                 await lintAction({
                     ...(args[0] as Record<string, unknown> | undefined ?? {}),
                     authToken,
@@ -117,7 +153,7 @@ export async function runCli(argv: string[] = process.argv): Promise<void> {
         .action(async (...args: unknown[]) => {
             const done = trackCommand('oml-render');
             try {
-                const authToken = await resolveServerRequestToken(authService);
+                const authToken = resolveServerRequestToken();
                 await renderAction({
                     ...(args[0] as Record<string, unknown> | undefined ?? {}),
                     authToken,
@@ -139,7 +175,7 @@ export async function runCli(argv: string[] = process.argv): Promise<void> {
         .action(async (...args: unknown[]) => {
             const done = trackCommand('oml-export');
             try {
-                const authToken = await resolveServerRequestToken(authService);
+                const authToken = resolveServerRequestToken();
                 await exportAction({
                     ...(args[0] as Record<string, unknown> | undefined ?? {}),
                     authToken,
@@ -160,7 +196,7 @@ export async function runCli(argv: string[] = process.argv): Promise<void> {
             const done = trackCommand('oml-reason');
             try {
                 const { reasonAction } = await import('./commands/reason.js');
-                const authToken = await resolveServerRequestToken(authService);
+                const authToken = resolveServerRequestToken();
                 await reasonAction({ ...(opts as Record<string, unknown>), authToken } as Parameters<typeof reasonAction>[0]);
                 done();
             } catch (err) {
@@ -176,7 +212,7 @@ export async function runCli(argv: string[] = process.argv): Promise<void> {
         .action(async (...args: unknown[]) => {
             const done = trackCommand('oml-validate');
             try {
-                const authToken = await resolveServerRequestToken(authService);
+                const authToken = resolveServerRequestToken();
                 await validateAction({
                     ...(args[0] as Record<string, unknown> | undefined ?? {}),
                     authToken,
@@ -188,67 +224,22 @@ export async function runCli(argv: string[] = process.argv): Promise<void> {
             }
         });
 
-    const server = program
-        .command('server')
-        .description('manage the standalone OML language server daemon');
-
-    server
-        .command('start [port]')
-        .option('-p, --port <port>', 'bind port (default: auto-select free port)')
-        .option('--workspace <workspace>', 'workspace root used by REST facade initialize (default: cwd)')
-        .description('start the OML server as a background daemon (CI/CD, requires OML_PLATFORM_API_KEY)')
-        .action(async (port: string | undefined, options: { port?: string; workspace?: string }) => {
-            await serverStartAction(port, { ...options, auth: await resolveServerStartAuth() });
-        });
-
-    server
-        .command('run [port]')
-        .option('-p, --port <port>', 'bind port (default: auto-select free port)')
-        .option('--workspace <workspace>', 'workspace root (default: cwd)')
-        .description('run the OML server in the foreground with interactive authentication (Ctrl-C to stop)')
-        .action(async (port: string | undefined, options: { port?: string; workspace?: string }) => {
-            await serverRunAction(port, { ...options, auth: await resolveServerRunAuth(authService) });
-        });
-
-    server
-        .command('stop')
-        .description('stop the OML language server daemon')
-        .action(async () => {
-            await serverStopAction();
-        });
-
-    server
-        .command('status')
-        .description('print server daemon status')
-        .action(async () => {
-            await serverStatusAction();
-        });
-
     program.hook('preAction', async (_thisCommand, actionCommand) => {
         if (
             actionCommand.name() === 'login'
             || actionCommand.name() === 'logout'
             || actionCommand.name() === 'whoami'
             || actionCommand.name() === 'start'
-            || actionCommand.name() === 'run'
             || actionCommand.name() === 'stop'
             || actionCommand.name() === 'status'
+            || actionCommand.name() === 'list'
         ) {
             return;
         }
         await assertServerRunning();
-        // Require either GitHub auth or API key, then connect to platform
-        if (!process.env.OML_PLATFORM_API_KEY) {
-            await authService.ensureAuthenticated('OML CLI');
-        }
-        await initializePlatform(authService);
     });
 
-    try {
-        await program.parseAsync(argv);
-    } finally {
-        await disposePlatform();
-    }
+    await program.parseAsync(argv);
     await updateCheck;
 }
 
@@ -319,53 +310,37 @@ function hasDebugFlag(argv: string[]): boolean {
     return argv.includes('--debug') || argv.includes('-d');
 }
 
-async function resolveServerRequestToken(authService: OmlCliAuthService): Promise<string | undefined> {
-    const apiKey = process.env.OML_PLATFORM_API_KEY?.trim();
-    if (apiKey && apiKey.length > 0) {
-        const oidcToken = process.env.OML_CI_TOKEN?.trim();
-        const apiBaseUrl = process.env.OML_PLATFORM_API_URL?.trim() ?? DEFAULT_API_BASE_URL;
-        const exchanged = await exchangeApiToken(apiBaseUrl, apiKey, oidcToken || undefined);
-        return exchanged.accessToken;
-    }
-    const snapshot = await authService.getServerAuthSnapshot();
-    return snapshot.accessToken;
+function resolveServerRequestToken(): string | undefined {
+    return undefined;
 }
 
 async function resolveServerStartAuth(): Promise<{ accessToken: string }> {
     const apiKey = process.env.OML_PLATFORM_API_KEY?.trim();
     if (!apiKey) {
         throw new CliExitError(
-            'OML_PLATFORM_API_KEY is not set. oml server start requires an API key for non-interactive use. ' +
-            'For interactive use, run \'oml server run\' instead.'
+            'OML_PLATFORM_API_KEY is not set. For interactive use, run \'oml start\'. ' +
+            'For non-interactive use, set OML_PLATFORM_API_KEY and retry.'
         );
     }
-    const oidcToken = process.env.OML_CI_TOKEN?.trim();
-    const apiBaseUrl = process.env.OML_PLATFORM_API_URL?.trim() ?? DEFAULT_API_BASE_URL;
-    const result = await exchangeApiToken(apiBaseUrl, apiKey, oidcToken || undefined);
-    return { accessToken: result.accessToken };
+    return { accessToken: apiKey };
 }
 
 async function resolveServerRunAuth(authService: OmlCliAuthService): Promise<{
     accessToken: string;
-    refreshToken: string;
-    expiresAtMs: number;
-    onRefresh: (newAccessToken: string, newRefreshToken: string, newExpiresAtMs: number) => Promise<void>;
 }> {
-    await authService.ensureAuthenticated('oml server run');
-    const snapshot = await authService.getServerAuthSnapshot();
-    if (!snapshot.refreshToken || snapshot.expiresAtMs === undefined) {
-        throw new CliExitError('Authentication session is incomplete. Run oml login again.');
+    let snapshot;
+    try {
+        snapshot = await authService.getServerAuthSnapshot();
+    } catch {
+        await authService.login({});
+        snapshot = await authService.getServerAuthSnapshot();
     }
     return {
         accessToken: snapshot.accessToken,
-        refreshToken: snapshot.refreshToken,
-        expiresAtMs: snapshot.expiresAtMs,
-        onRefresh: async (newAccessToken, newRefreshToken, newExpiresAtMs) => {
-            await authService.storeRefreshedTokens(newAccessToken, newRefreshToken, newExpiresAtMs);
-        },
     };
 }
 
+
 function formatDetailedError(error: unknown): string {
     if (!(error instanceof Error)) {
         return String(error);

package/src/commands/server/actions.ts

@@ -9,6 +9,7 @@ import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { spawn, execFile, type ChildProcess } from 'node:child_process';
 import { promisify } from 'node:util';
+import type { OmlCliAuthService } from '../../auth/auth.js';
 
 const DEFAULT_HOST = '127.0.0.1';
 const STARTUP_TIMEOUT_MS = 15_000;
@@ -34,6 +35,7 @@ type ServerLockState = {
     pid: number;
     port: number;
     owner?: 'daemon' | 'extension';
+    workspaceRoot?: string;
 };
 
 function workspaceHash(workspaceRoot: string): string {
@@ -56,7 +58,7 @@ async function cleanupStateFile(paths: ServerStatePaths): Promise<void> {
 
 function parseServerLock(raw: string): ServerLockState | undefined {
     try {
-        const parsed = JSON.parse(raw) as { pid?: unknown; port?: unknown; owner?: unknown };
+        const parsed = JSON.parse(raw) as { pid?: unknown; port?: unknown; owner?: unknown; workspaceRoot?: unknown };
         const pid = Number(parsed.pid);
         const port = Number(parsed.port);
         if (!Number.isFinite(pid) || !Number.isFinite(port)) {
@@ -70,7 +72,10 @@ function parseServerLock(raw: string): ServerLockState | undefined {
         const owner = parsed.owner === 'daemon' || parsed.owner === 'extension'
             ? parsed.owner
             : undefined;
-        return { pid: pidInt, port: portInt, owner };
+        const workspaceRoot = typeof parsed.workspaceRoot === 'string' && parsed.workspaceRoot.trim().length > 0
+            ? parsed.workspaceRoot.trim()
+            : undefined;
+        return { pid: pidInt, port: portInt, owner, workspaceRoot };
     } catch {
         return undefined;
     }
@@ -88,6 +93,50 @@ async function readServerLock(lockFile: string): Promise<ServerLockState | undef
     }
 }
 
+type RunningServer = {
+    pid: number;
+    port: number;
+    owner: 'daemon' | 'extension' | 'unknown';
+    workspaceRoot?: string;
+    lockFile: string;
+};
+
+async function listRunningServers(): Promise<RunningServer[]> {
+    const baseDir = path.join(os.homedir(), '.oml', 'workspaces');
+    let entries: string[];
+    try {
+        entries = await fs.readdir(baseDir);
+    } catch {
+        return [];
+    }
+
+    const servers: RunningServer[] = [];
+    for (const entry of entries) {
+        const lockFile = path.join(baseDir, entry, 'server.lock');
+        const state = await readServerLock(lockFile);
+        if (!state) {
+            continue;
+        }
+        if (!isProcessAlive(state.pid)) {
+            await fs.rm(lockFile, { force: true });
+            continue;
+        }
+        servers.push({
+            pid: state.pid,
+            port: state.port,
+            owner: state.owner ?? 'unknown',
+            workspaceRoot: state.workspaceRoot,
+            lockFile,
+        });
+    }
+
+    servers.sort((left, right) =>
+        String(left.workspaceRoot ?? '').localeCompare(String(right.workspaceRoot ?? ''))
+        || left.port - right.port
+    );
+    return servers;
+}
+
 function isProcessAlive(pid: number): boolean {
     try {
         process.kill(pid, 0);
@@ -319,7 +368,7 @@ async function serverStartDetached(
 
     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");
+    console.log("Use 'oml stop' to stop the server");
 }
 
 export async function serverStopAction(): Promise<void> {
@@ -368,14 +417,25 @@ export async function serverStatusAction(): Promise<void> {
     process.stdout.write(`${output}\n`);
 }
 
+export async function serverListAction(): Promise<void> {
+    const servers = await listRunningServers();
+    if (servers.length === 0) {
+        process.stdout.write('No active OML servers.\n');
+        return;
+    }
+    process.stdout.write('Active OML servers:\n');
+    for (const server of servers) {
+        const workspace = server.workspaceRoot ?? '(unknown workspace)';
+        process.stdout.write(`- ${workspace} | http://${DEFAULT_HOST}:${server.port} | pid ${server.pid} | owner ${server.owner}\n`);
+    }
+}
+
 export type RunServerOptions = {
     port?: number | string;
     workspace?: string;
+    authService: OmlCliAuthService;
     auth: {
         accessToken: string;
-        refreshToken: string;
-        expiresAtMs: number;
-        onRefresh: (newAccessToken: string, newRefreshToken: string, newExpiresAtMs: number) => Promise<void>;
     };
 };
 
@@ -388,8 +448,8 @@ function sendLspNotification(childStdin: NodeJS.WritableStream, method: string,
 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.'
+            'OML_PLATFORM_API_KEY is set but interactive startup uses OAuth credentials. ' +
+            'Use \'oml start\' directly to let the CLI choose the correct auth mode.'
         );
     }
 
@@ -440,38 +500,59 @@ export async function serverRunAction(portArg: number | string | undefined, opti
 
     const stdin = child.stdin;
     const REFRESH_INTERVAL_MS = 60 * 60 * 1000;
-    let currentRefreshToken = options.auth.refreshToken;
-    let currentExpiresAtMs = options.auth.expiresAtMs;
+    const REFRESH_RETRY_BASE_MS = 15_000;
+    const REFRESH_RETRY_MAX_MS = 5 * 60 * 1000;
+    let currentAccessToken = options.auth.accessToken;
+    let refreshFailureCount = 0;
+    let refreshTimer: NodeJS.Timeout | undefined;
+
+    const scheduleRefresh = (delayMs: number): void => {
+        if (refreshTimer) {
+            clearTimeout(refreshTimer);
+        }
+        refreshTimer = setTimeout(() => {
+            void runRefreshCycle();
+        }, delayMs);
+    };
+
+    const retryDelayMs = (failureCount: number): number => {
+        const step = Math.max(0, failureCount - 1);
+        const candidate = REFRESH_RETRY_BASE_MS * (2 ** step);
+        return Math.min(REFRESH_RETRY_MAX_MS, candidate);
+    };
 
-    const refreshTimer = setInterval(async () => {
+    const runRefreshCycle = async (): Promise<void> => {
         try {
-            const leeway = 5 * 60 * 1000;
-            if (Date.now() + leeway < currentExpiresAtMs) {
-                return;
+            const snapshot = await options.authService.getServerAuthSnapshot();
+            if (snapshot.accessToken !== currentAccessToken) {
+                currentAccessToken = snapshot.accessToken;
+                sendLspNotification(stdin, '$/tokenRefreshed', { accessToken: snapshot.accessToken });
             }
-            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);
+            refreshFailureCount = 0;
+            scheduleRefresh(REFRESH_INTERVAL_MS);
         } catch {
-            // Refresh failure is non-fatal — server continues with cached token.
+            // Keep running with the in-memory token and retry sooner while offline.
+            refreshFailureCount += 1;
+            scheduleRefresh(retryDelayMs(refreshFailureCount));
         }
-    }, REFRESH_INTERVAL_MS);
+    };
+
+    scheduleRefresh(REFRESH_INTERVAL_MS);
 
     await new Promise<void>((resolve) => {
         const shutdown = (): void => {
-            clearInterval(refreshTimer);
+            if (refreshTimer) {
+                clearTimeout(refreshTimer);
+            }
             child.kill('SIGTERM');
             resolve();
         };
         process.once('SIGINT', shutdown);
         process.once('SIGTERM', shutdown);
         child.once('exit', () => {
-            clearInterval(refreshTimer);
+            if (refreshTimer) {
+                clearTimeout(refreshTimer);
+            }
             resolve();
         });
     });

package/src/commands/server/require.ts

@@ -8,7 +8,7 @@ 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')";
+const START_SERVER_HINT = "start server first (run 'oml start')";
 
 type ServerState = {
     pid: number;