@syncular/cli 0.0.0-108 → 0.0.0-113

package/src/commands/console.ts

@@ -1,252 +0,0 @@
-import { spawn } from 'node:child_process';
-import {
-  createServer,
-  type IncomingHttpHeaders,
-  type IncomingMessage,
-  type ServerResponse,
-} from 'node:http';
-import process from 'node:process';
-import { createConsoleStaticResponder } from 'syncular/console-server';
-import {
-  optionalBooleanFlag,
-  optionalNullableFlag as optionalFlag,
-} from '../flags';
-import { printError } from '../output';
-
-const DEFAULT_HOST = '127.0.0.1';
-const DEFAULT_PORT = 4310;
-
-function parsePort(value: string | null): number | null {
-  if (!value) {
-    return DEFAULT_PORT;
-  }
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
-    return null;
-  }
-  return parsed;
-}
-
-function resolveToken(flagValues: Map<string, string>): string | undefined {
-  const directToken = optionalFlag(flagValues, '--token');
-  if (directToken) {
-    return directToken;
-  }
-
-  const tokenEnvName = optionalFlag(flagValues, '--token-env');
-  if (!tokenEnvName) {
-    return undefined;
-  }
-
-  const envToken = process.env[tokenEnvName]?.trim();
-  if (!envToken) {
-    throw new Error(
-      `Environment variable ${tokenEnvName} is empty or undefined.`
-    );
-  }
-
-  return envToken;
-}
-
-function normalizeHost(value: string | null): string {
-  return value ?? DEFAULT_HOST;
-}
-
-function formatHostForUrl(host: string): string {
-  return host.includes(':') ? `[${host}]` : host;
-}
-
-function browserHost(host: string): string {
-  if (host === '0.0.0.0' || host === '::') {
-    return 'localhost';
-  }
-  return host;
-}
-
-function toHeaders(headers: IncomingHttpHeaders): Headers {
-  const result = new Headers();
-  for (const [name, value] of Object.entries(headers)) {
-    if (value === undefined) continue;
-    if (Array.isArray(value)) {
-      for (const entry of value) {
-        result.append(name, entry);
-      }
-      continue;
-    }
-    result.set(name, value);
-  }
-  return result;
-}
-
-function toRequest(request: IncomingMessage): Request {
-  const origin = `http://${request.headers.host ?? 'localhost'}`;
-  const requestUrl = new URL(request.url ?? '/', origin);
-  return new Request(requestUrl, {
-    method: request.method ?? 'GET',
-    headers: toHeaders(request.headers),
-  });
-}
-
-async function writeFetchResponse(
-  response: ServerResponse,
-  fetchResponse: Response,
-  method: string
-): Promise<void> {
-  response.statusCode = fetchResponse.status;
-  for (const [name, value] of fetchResponse.headers.entries()) {
-    response.setHeader(name, value);
-  }
-
-  if (method === 'HEAD' || fetchResponse.body === null) {
-    response.end();
-    return;
-  }
-
-  const body = Buffer.from(await fetchResponse.arrayBuffer());
-  response.end(body);
-}
-
-async function openInBrowser(url: string): Promise<void> {
-  await new Promise<void>((resolvePromise, rejectPromise) => {
-    let command = '';
-    let commandArgs: string[] = [];
-
-    if (process.platform === 'darwin') {
-      command = 'open';
-      commandArgs = [url];
-    } else if (process.platform === 'win32') {
-      command = 'cmd';
-      commandArgs = ['/c', 'start', '', url];
-    } else {
-      command = 'xdg-open';
-      commandArgs = [url];
-    }
-
-    const child = spawn(command, commandArgs, {
-      stdio: 'ignore',
-      detached: true,
-    });
-    child.once('error', rejectPromise);
-    child.once('spawn', () => {
-      child.unref();
-      resolvePromise();
-    });
-  });
-}
-
-export async function runConsole(
-  flagValues: Map<string, string>
-): Promise<number> {
-  try {
-    const host = normalizeHost(optionalFlag(flagValues, '--host'));
-    const port = parsePort(optionalFlag(flagValues, '--port'));
-    if (port === null) {
-      throw new Error('Invalid --port value. Use an integer from 0 to 65535.');
-    }
-
-    const serverUrl = optionalFlag(flagValues, '--server-url');
-    if (serverUrl) {
-      try {
-        new URL(serverUrl);
-      } catch {
-        throw new Error(`Invalid --server-url: ${serverUrl}`);
-      }
-    }
-
-    const token = resolveToken(flagValues);
-    const shouldOpen = optionalBooleanFlag(flagValues, '--open', false);
-
-    const consoleStaticResponder = createConsoleStaticResponder({
-      mountPath: '/',
-      defaultPrefill: {
-        basePath: '/',
-        serverUrl: serverUrl ?? undefined,
-        token,
-      },
-    });
-
-    const server = createServer((request, response) => {
-      const method = request.method ?? 'GET';
-      if (method !== 'GET' && method !== 'HEAD') {
-        response.statusCode = 405;
-        response.end('Method Not Allowed');
-        return;
-      }
-
-      void (async () => {
-        const fetchRequest = toRequest(request);
-        const fetchResponse = await consoleStaticResponder(fetchRequest);
-        if (!fetchResponse) {
-          response.statusCode = 404;
-          response.end('Not Found');
-          return;
-        }
-
-        await writeFetchResponse(response, fetchResponse, method);
-      })().catch((error: unknown) => {
-        const message = error instanceof Error ? error.message : String(error);
-        printError(`Console request failed: ${message}`);
-        if (!response.headersSent) {
-          response.statusCode = 500;
-        }
-        response.end('Internal Server Error');
-      });
-    });
-
-    await new Promise<void>((resolvePromise, rejectPromise) => {
-      server.once('error', rejectPromise);
-      server.listen(port, host, () => {
-        server.off('error', rejectPromise);
-        resolvePromise();
-      });
-    }).catch((error: unknown) => {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to start console server: ${message}`);
-    });
-
-    const address = server.address();
-    if (!address || typeof address === 'string') {
-      throw new Error('Failed to resolve console server address.');
-    }
-
-    const localUrl = `http://${formatHostForUrl(host)}:${address.port}`;
-    console.log(`Console running at ${localUrl}`);
-    if (serverUrl) {
-      console.log(`Using API server: ${serverUrl}`);
-    } else {
-      console.log(
-        'No API server configured. Set --server-url to preconfigure connection.'
-      );
-    }
-    if (token) {
-      console.log('Using preconfigured token.');
-    }
-
-    if (shouldOpen) {
-      const openUrl = `http://${browserHost(host)}:${address.port}`;
-      try {
-        await openInBrowser(openUrl);
-      } catch (error: unknown) {
-        const message = error instanceof Error ? error.message : String(error);
-        printError(`Unable to open browser automatically: ${message}`);
-        console.log(`Open manually: ${openUrl}`);
-      }
-    }
-
-    await new Promise<void>((resolvePromise) => {
-      const shutdown = () => {
-        process.off('SIGINT', shutdown);
-        process.off('SIGTERM', shutdown);
-        server.close(() => resolvePromise());
-      };
-
-      process.on('SIGINT', shutdown);
-      process.on('SIGTERM', shutdown);
-    });
-
-    return 0;
-  } catch (error: unknown) {
-    printError(error instanceof Error ? error.message : 'Console failed.');
-    return 1;
-  }
-}