@auraindustry/aurajs 0.0.7 → 0.1.1

package/src/session-server.mjs

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+
+import net from 'node:net';
+import { existsSync, mkdirSync, rmSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+
+import {
+  DEV_SESSION_REQUEST_SCHEMA_VERSION,
+  DEV_SESSION_RESPONSE_SCHEMA_VERSION,
+} from './session-protocol.mjs';
+import {
+  HeadlessTestError,
+} from './headless-test.mjs';
+import {
+  applySessionState,
+  advanceSessionFrames,
+  bootSessionRuntime,
+  exportSessionInspect,
+  exportSessionState,
+  getSessionActionSchema,
+  runSessionAction,
+} from './session-runtime.mjs';
+
+function parseArgs(argv) {
+  const parsed = {
+    projectRoot: process.cwd(),
+    file: 'src/main.js',
+    sessionId: null,
+    name: null,
+    socketPath: null,
+    width: 1280,
+    height: 720,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+
+    if (token === '--project-root') {
+      parsed.projectRoot = resolve(argv[i + 1] || process.cwd());
+      i += 1;
+      continue;
+    }
+    if (token === '--file') {
+      parsed.file = argv[i + 1] || parsed.file;
+      i += 1;
+      continue;
+    }
+    if (token === '--session-id') {
+      parsed.sessionId = argv[i + 1] || null;
+      i += 1;
+      continue;
+    }
+    if (token === '--name') {
+      parsed.name = argv[i + 1] || null;
+      i += 1;
+      continue;
+    }
+    if (token === '--socket-path') {
+      parsed.socketPath = argv[i + 1] || null;
+      i += 1;
+      continue;
+    }
+    if (token === '--width') {
+      parsed.width = Number(argv[i + 1] || parsed.width);
+      i += 1;
+      continue;
+    }
+    if (token === '--height') {
+      parsed.height = Number(argv[i + 1] || parsed.height);
+      i += 1;
+      continue;
+    }
+  }
+
+  if (!parsed.sessionId || !parsed.socketPath) {
+    throw new Error('session server requires --session-id and --socket-path');
+  }
+
+  return parsed;
+}
+
+function createResponse({ ok, reasonCode, result = null, detail = null }) {
+  const response = {
+    schemaVersion: DEV_SESSION_RESPONSE_SCHEMA_VERSION,
+    ok: ok === true,
+    reasonCode: typeof reasonCode === 'string' && reasonCode
+      ? reasonCode
+      : ok === true
+        ? 'session_request_ok'
+        : 'session_request_failed',
+  };
+
+  if (detail) {
+    response.detail = String(detail);
+  }
+  if (result !== null) {
+    response.result = result;
+  }
+
+  return response;
+}
+
+function createSessionMeta(parsed, runtime) {
+  return {
+    sessionId: parsed.sessionId,
+    name: parsed.name || parsed.sessionId,
+    mode: 'headless',
+    pid: process.pid,
+    projectRoot: parsed.projectRoot,
+    entryFile: runtime.entryFile,
+    socketPath: parsed.socketPath,
+    logPath: null,
+    createdAt: new Date().toISOString(),
+    frameIndex: runtime.frameIndex,
+    elapsedSeconds: runtime.elapsedSeconds,
+    requestCount: 0,
+  };
+}
+
+function describeSession(meta, runtime) {
+  return {
+    sessionId: meta.sessionId,
+    name: meta.name,
+    mode: meta.mode,
+    pid: meta.pid,
+    projectRoot: meta.projectRoot,
+    entryFile: meta.entryFile,
+    socketPath: meta.socketPath,
+    createdAt: meta.createdAt,
+    frameIndex: runtime.frameIndex,
+    elapsedSeconds: runtime.elapsedSeconds,
+    requestCount: meta.requestCount,
+  };
+}
+
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  const socketPath = parsed.socketPath;
+
+  if (process.platform !== 'win32' && existsSync(socketPath)) {
+    rmSync(socketPath, { force: true });
+  }
+  if (process.platform !== 'win32') {
+    mkdirSync(dirname(socketPath), { recursive: true });
+  }
+
+  const runtime = await bootSessionRuntime({
+    projectRoot: parsed.projectRoot,
+    file: parsed.file,
+    width: parsed.width,
+    height: parsed.height,
+    outFile: `.aura/session/${parsed.sessionId}.bundle.js`,
+  });
+  const meta = createSessionMeta(parsed, runtime);
+
+  let server = null;
+  let shuttingDown = false;
+
+  const shutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+
+    if (server) {
+      await new Promise((resolveClose) => {
+        server.close(() => resolveClose());
+      });
+    }
+    if (process.platform !== 'win32' && existsSync(socketPath)) {
+      rmSync(socketPath, { force: true });
+    }
+    process.exit(0);
+  };
+
+  process.on('SIGTERM', () => {
+    void shutdown();
+  });
+  process.on('SIGINT', () => {
+    void shutdown();
+  });
+
+  server = net.createServer((socket) => {
+    socket.setEncoding('utf8');
+    let buffer = '';
+    let handled = false;
+
+    const writeResponse = (payload) => {
+      if (handled) return;
+      handled = true;
+      socket.end(`${JSON.stringify(payload)}\n`);
+    };
+
+    const writeFailure = (reasonCode, detail) => {
+      writeResponse(createResponse({
+        ok: false,
+        reasonCode,
+        detail,
+      }));
+    };
+
+    socket.on('data', (chunk) => {
+      buffer += chunk;
+      const newlineIndex = buffer.indexOf('\n');
+      if (newlineIndex === -1) return;
+
+      const line = buffer.slice(0, newlineIndex).trim();
+      if (!line) {
+        writeFailure('session_invalid_request', 'request payload is empty');
+        return;
+      }
+
+      let request;
+      try {
+        request = JSON.parse(line);
+      } catch (error) {
+        writeFailure('session_invalid_request', error.message);
+        return;
+      }
+
+      void (async () => {
+        try {
+          if (!request || typeof request !== 'object' || Array.isArray(request)) {
+            writeFailure('session_invalid_request', 'request must be an object');
+            return;
+          }
+          if (request.schemaVersion !== DEV_SESSION_REQUEST_SCHEMA_VERSION) {
+            writeFailure('schema_version_mismatch', `expected ${DEV_SESSION_REQUEST_SCHEMA_VERSION}`);
+            return;
+          }
+          if (typeof request.method !== 'string' || request.method.trim().length === 0) {
+            writeFailure('session_invalid_request', 'request.method must be a non-empty string');
+            return;
+          }
+
+          const method = request.method.trim();
+          const params = request.params && typeof request.params === 'object' && !Array.isArray(request.params)
+            ? request.params
+            : {};
+
+          meta.requestCount += 1;
+
+          if (method === 'session.ping' || method === 'session.describe') {
+            writeResponse(createResponse({
+              ok: true,
+              reasonCode: 'session_request_ok',
+              result: describeSession(meta, runtime),
+            }));
+            return;
+          }
+
+          if (method === 'session.shutdown') {
+            writeResponse(createResponse({
+              ok: true,
+              reasonCode: 'session_closed',
+              result: {
+                sessionId: meta.sessionId,
+                closed: true,
+              },
+            }));
+            setTimeout(() => {
+              void shutdown();
+            }, 10);
+            return;
+          }
+
+          if (method === 'state.export') {
+            const frames = Number.isInteger(Number(params.frames)) && Number(params.frames) >= 0
+              ? Number(params.frames)
+              : 0;
+            if (frames > 0) {
+              await advanceSessionFrames(runtime, frames);
+            }
+            const exportResult = exportSessionState(runtime, {
+              mode: params.mode || 'headless',
+              capturedAt: params.capturedAt ?? null,
+            });
+            writeResponse(createResponse({
+              ok: true,
+              reasonCode: 'session_request_ok',
+              result: { exportResult },
+            }));
+            return;
+          }
+
+          if (method === 'state.apply') {
+            const applyResult = applySessionState(runtime, params.payload);
+            writeResponse(createResponse({
+              ok: true,
+              reasonCode: 'session_request_ok',
+              result: { applyResult },
+            }));
+            return;
+          }
+
+          if (method === 'action.schema') {
+            const schemaResult = getSessionActionSchema(runtime);
+            writeResponse(createResponse({
+              ok: true,
+              reasonCode: 'session_request_ok',
+              result: { schemaResult },
+            }));
+            return;
+          }
+
+          if (method === 'action.run') {
+            const runResult = await runSessionAction(runtime, {
+              request: params.request,
+              frames: params.frames ?? 0,
+              includeState: params.includeState === true,
+              mode: params.mode || 'headless',
+              capturedAt: params.capturedAt ?? null,
+            });
+            writeResponse(createResponse({
+              ok: true,
+              reasonCode: 'session_request_ok',
+              result: runResult,
+            }));
+            return;
+          }
+
+          if (method === 'inspect.export') {
+            const runtimeInspectorSnapshot = await exportSessionInspect(runtime, {
+              frames: params.frames ?? 0,
+            });
+            writeResponse(createResponse({
+              ok: true,
+              reasonCode: 'session_request_ok',
+              result: { runtimeInspectorSnapshot },
+            }));
+            return;
+          }
+
+          writeFailure('session_method_unknown', `unknown session method "${method}"`);
+        } catch (error) {
+          writeFailure('session_request_failed', error instanceof Error ? error.message : String(error));
+        }
+      })();
+    });
+
+    socket.on('error', () => {});
+  });
+
+  server.on('error', async (error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    await shutdown();
+  });
+
+  await new Promise((resolveListen, rejectListen) => {
+    server.listen(socketPath, () => resolveListen());
+    server.once('error', (error) => rejectListen(error));
+  });
+}
+
+main().catch(async (error) => {
+  if (error instanceof HeadlessTestError) {
+    console.error(error.message);
+  } else {
+    console.error(error instanceof Error ? error.stack || error.message : String(error));
+  }
+  process.exit(1);
+});