@codeyam/codeyam-cli 0.1.0-staging.b8a55ba → 0.1.0-staging.b8f4f94

package/codeyam-cli/src/webserver/scripts/codeyam-preload.mjs

@@ -0,0 +1,175 @@
+/**
+ * Node.js preload module for CodeYam editor proxy.
+ *
+ * Loaded via NODE_OPTIONS='--import /path/to/codeyam-preload.mjs' in the
+ * dev server process. Patches global fetch and http/https.request so that
+ * SSR fetches (Next.js server components, server actions, etc.) are routed
+ * through the CodeYam proxy instead of hitting the dev server directly.
+ *
+ * Must be .mjs (native ESM) because --import requires it.
+ * No TypeScript, no build step, no dependencies.
+ */
+
+import http from 'node:http';
+import https from 'node:https';
+import fs from 'node:fs';
+import path from 'node:path';
+
+let proxyConfig = null;
+let configLoaded = false;
+
+/**
+ * Lazily load the proxy config from .codeyam/proxy-config.json.
+ * Returns null if the file doesn't exist yet (proxy still starting).
+ */
+function getProxyConfig() {
+  if (configLoaded && proxyConfig) return proxyConfig;
+
+  // Try env var first (most reliable)
+  const proxyUrl = process.env.CODEYAM_PROXY_URL;
+  const devServerUrl = process.env.CODEYAM_DEV_SERVER_URL;
+  if (proxyUrl && devServerUrl) {
+    proxyConfig = { proxyUrl, devServerUrl };
+    configLoaded = true;
+    return proxyConfig;
+  }
+
+  // Fall back to config file
+  try {
+    const cwd = process.cwd();
+    const configPath = path.join(cwd, '.codeyam', 'proxy-config.json');
+    if (fs.existsSync(configPath)) {
+      const raw = fs.readFileSync(configPath, 'utf-8');
+      proxyConfig = JSON.parse(raw);
+      configLoaded = true;
+      return proxyConfig;
+    }
+  } catch {
+    // File doesn't exist yet or is invalid — that's fine
+  }
+
+  return null;
+}
+
+/**
+ * Check if a URL string targets the dev server and return the redirected URL.
+ */
+function redirectUrl(urlStr, config) {
+  try {
+    const parsed = new URL(urlStr);
+    const dev = new URL(config.devServerUrl);
+    const proxy = new URL(config.proxyUrl);
+
+    if (parsed.hostname === dev.hostname && parsed.port === dev.port) {
+      parsed.hostname = proxy.hostname;
+      parsed.port = proxy.port;
+      parsed.protocol = proxy.protocol;
+      return parsed.toString();
+    }
+  } catch {
+    // Invalid URL — pass through
+  }
+  return urlStr;
+}
+
+/**
+ * Check if http.request options target the dev server and patch them.
+ */
+function redirectOptions(options, config) {
+  const dev = new URL(config.devServerUrl);
+  const proxy = new URL(config.proxyUrl);
+  const devPort = parseInt(dev.port, 10);
+  const proxyPort = parseInt(proxy.port, 10);
+
+  if (options.hostname && parseInt(String(options.port), 10) === devPort && options.hostname === dev.hostname) {
+    return {
+      ...options,
+      hostname: proxy.hostname,
+      port: proxyPort,
+      headers: options.headers
+        ? { ...options.headers, host: `${proxy.hostname}:${proxyPort}` }
+        : options.headers,
+    };
+  }
+
+  if (options.host) {
+    const expectedHost = `${dev.hostname}:${devPort}`;
+    if (options.host === expectedHost) {
+      return {
+        ...options,
+        host: `${proxy.hostname}:${proxyPort}`,
+      };
+    }
+  }
+
+  return options;
+}
+
+// --- Patch global fetch ---
+
+const originalFetch = globalThis.fetch;
+
+if (originalFetch) {
+  globalThis.fetch = function patchedFetch(input, init) {
+    const config = getProxyConfig();
+    if (!config) return originalFetch.call(this, input, init);
+
+    if (typeof input === 'string') {
+      const redirected = redirectUrl(input, config);
+      if (redirected !== input) {
+        return originalFetch.call(this, redirected, init);
+      }
+    } else if (input instanceof URL) {
+      const redirected = redirectUrl(input.toString(), config);
+      if (redirected !== input.toString()) {
+        return originalFetch.call(this, redirected, init);
+      }
+    } else if (input instanceof Request) {
+      const redirected = redirectUrl(input.url, config);
+      if (redirected !== input.url) {
+        return originalFetch.call(this, new Request(redirected, input), init);
+      }
+    }
+
+    return originalFetch.call(this, input, init);
+  };
+}
+
+// --- Patch http.request and https.request ---
+
+function patchModule(mod, protocol) {
+  const originalRequest = mod.request;
+  const originalGet = mod.get;
+
+  mod.request = function patchedRequest(urlOrOptions, optionsOrCallback, callback) {
+    const config = getProxyConfig();
+    if (!config) return originalRequest.call(this, urlOrOptions, optionsOrCallback, callback);
+
+    // http.request(url, options, callback)
+    if (typeof urlOrOptions === 'string' || urlOrOptions instanceof URL) {
+      const urlStr = typeof urlOrOptions === 'string' ? urlOrOptions : urlOrOptions.toString();
+      const redirected = redirectUrl(urlStr, config);
+      if (redirected !== urlStr) {
+        // Redirect to proxy — force http since proxy is always http
+        return http.request.call(http, redirected, optionsOrCallback, callback);
+      }
+      return originalRequest.call(this, urlOrOptions, optionsOrCallback, callback);
+    }
+
+    // http.request(options, callback)
+    const redirected = redirectOptions(urlOrOptions, config);
+    if (redirected !== urlOrOptions) {
+      return http.request.call(http, redirected, optionsOrCallback);
+    }
+    return originalRequest.call(this, urlOrOptions, optionsOrCallback, callback);
+  };
+
+  mod.get = function patchedGet(urlOrOptions, optionsOrCallback, callback) {
+    const req = mod.request(urlOrOptions, optionsOrCallback, callback);
+    req.end();
+    return req;
+  };
+}
+
+patchModule(http, 'http');
+patchModule(https, 'https');

package/codeyam-cli/src/webserver/scripts/journalCapture.ts

@@ -0,0 +1,140 @@
+#!/usr/bin/env npx tsx
+/**
+ * Lightweight Playwright script for journal screenshots.
+ * No DB lookups, no mock data regeneration — just navigate and screenshot.
+ *
+ * Usage: npx tsx journalCapture.ts '<json-args>'
+ * Args: { url, outputPath, viewportWidth?, viewportHeight? }
+ */
+
+import { chromium } from 'playwright';
+
+interface CaptureArgs {
+  url: string;
+  outputPath: string;
+  viewportWidth?: number;
+  viewportHeight?: number;
+  /** CSS selector for element-level screenshot (e.g. '#codeyam-capture').
+   *  If provided, screenshots just that element instead of the full page. */
+  selector?: string;
+}
+
+const MAX_RETRIES = 2;
+const GOTO_TIMEOUT_MS = 15_000;
+const SETTLE_DELAY_MS = 500;
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length < 1) {
+    console.error('Usage: journalCapture.ts <json-args>');
+    process.exit(1);
+  }
+
+  const config: CaptureArgs = JSON.parse(args[0]);
+  const {
+    url,
+    outputPath,
+    viewportWidth = 1280,
+    viewportHeight = 720,
+    selector,
+  } = config;
+
+  console.log(`[JournalCapture] URL: ${url}`);
+  console.log(`[JournalCapture] Output: ${outputPath}`);
+  console.log(`[JournalCapture] Viewport: ${viewportWidth}x${viewportHeight}`);
+
+  const browser = await chromium.launch({ headless: true });
+
+  try {
+    const context = await browser.newContext({
+      viewport: { width: viewportWidth, height: viewportHeight },
+    });
+    const page = await context.newPage();
+
+    // Log console messages from the page for debugging
+    page.on('console', (msg) => {
+      if (msg.type() === 'error') {
+        console.log(`[JournalCapture] Page console.error: ${msg.text()}`);
+      }
+    });
+
+    // Log failed network requests
+    page.on('requestfailed', (request) => {
+      console.log(
+        `[JournalCapture] Network failed: ${request.method()} ${request.url()} — ${request.failure()?.errorText || 'unknown'}`,
+      );
+    });
+
+    let lastError: Error | null = null;
+
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        console.log(
+          `[JournalCapture] Navigating (attempt ${attempt}/${MAX_RETRIES})...`,
+        );
+
+        const response = await page.goto(url, {
+          waitUntil: 'networkidle',
+          timeout: GOTO_TIMEOUT_MS,
+        });
+
+        if (response) {
+          console.log(
+            `[JournalCapture] Page loaded: status=${response.status()}, url=${response.url()}`,
+          );
+        }
+
+        // Brief settle time for any client-side rendering/animations
+        await page.waitForTimeout(SETTLE_DELAY_MS);
+
+        if (selector) {
+          // Element-level screenshot — captures just the wrapper element
+          const element = page.locator(selector);
+          try {
+            await element.waitFor({ state: 'visible', timeout: 5000 });
+            await element.screenshot({ path: outputPath });
+            console.log(
+              `[JournalCapture] Element screenshot: selector=${selector}`,
+            );
+          } catch {
+            // Selector not found — fall back to full-page screenshot
+            console.warn(
+              `[JournalCapture] Selector "${selector}" not found, falling back to full page`,
+            );
+            await page.screenshot({ path: outputPath, fullPage: true });
+          }
+        } else {
+          await page.screenshot({ path: outputPath, fullPage: true });
+        }
+
+        console.log(
+          `[JournalCapture] RESULT:${JSON.stringify({ success: true, path: outputPath })}`,
+        );
+        return; // Success
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        console.warn(
+          `[JournalCapture] Attempt ${attempt} failed: ${lastError.message}`,
+        );
+
+        if (attempt < MAX_RETRIES) {
+          // Wait a bit before retrying (server might still be starting)
+          const backoffMs = attempt * 2000;
+          console.log(`[JournalCapture] Retrying in ${backoffMs}ms...`);
+          await new Promise((r) => setTimeout(r, backoffMs));
+        }
+      }
+    }
+
+    // All retries exhausted
+    const message = lastError?.message || 'Unknown error';
+    console.error(
+      `[JournalCapture] All ${MAX_RETRIES} attempts failed: ${message}`,
+    );
+    process.exit(1);
+  } finally {
+    await browser.close();
+  }
+}
+
+void main();