codex-lens 0.1.0

package/src/lib/log-manager.js

@@ -0,0 +1,140 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeSync } from 'fs';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+
+const DEFAULT_LOG_DIR = join(homedir(), '.codex-viewer');
+
+export class LogManager {
+  constructor(logDir = DEFAULT_LOG_DIR) {
+    this.logDir = logDir;
+    this.ensureLogDir();
+  }
+
+  ensureLogDir() {
+    if (!existsSync(this.logDir)) {
+      mkdirSync(this.logDir, { recursive: true });
+    }
+  }
+
+  getLogFilePath(projectName) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return join(this.logDir, `${projectName}_${timestamp}.jsonl`);
+  }
+
+  appendEntry(logFile, entry) {
+    try {
+      const dir = dirname(logFile);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      appendFileSync(logFile, JSON.stringify(entry) + '\n');
+    } catch (error) {
+      console.error('[LogManager] Failed to append entry:', error.message);
+    }
+  }
+
+  readLogFile(logFile) {
+    if (!existsSync(logFile)) {
+      return [];
+    }
+
+    try {
+      const content = readFileSync(logFile, 'utf-8');
+      const lines = content.split('\n').filter(l => l.trim());
+      return lines.map(line => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter(Boolean);
+    } catch (error) {
+      console.error('[LogManager] Failed to read log file:', error.message);
+      return [];
+    }
+  }
+
+  listLogFiles(projectName) {
+    try {
+      if (!existsSync(this.logDir)) {
+        return [];
+      }
+
+      const files = readdirSync(this.logDir)
+        .filter(f => f.startsWith(projectName + '_') && f.endsWith('.jsonl'))
+        .map(f => {
+          const stats = statSync(join(this.logDir, f));
+          return {
+            name: f,
+            path: join(this.logDir, f),
+            size: stats.size,
+            modified: stats.mtime
+          };
+        })
+        .sort((a, b) => b.modified - a.modified);
+
+      return files;
+    } catch (error) {
+      console.error('[LogManager] Failed to list log files:', error.message);
+      return [];
+    }
+  }
+
+  deleteOldLogs(projectName, keepCount = 10) {
+    try {
+      const files = this.listLogFiles(projectName);
+      const toDelete = files.slice(keepCount);
+
+      for (const file of toDelete) {
+        unlinkSync(file.path);
+        console.log(`[LogManager] Deleted old log: ${file.name}`);
+      }
+    } catch (error) {
+      console.error('[LogManager] Failed to delete old logs:', error.message);
+    }
+  }
+
+  getRecentLog(projectName) {
+    const files = this.listLogFiles(projectName);
+    if (files.length > 0) {
+      return files[0];
+    }
+    return null;
+  }
+
+  writeSessionMeta(logFile, meta) {
+    this.appendEntry(logFile, {
+      type: 'session_meta',
+      timestamp: new Date().toISOString(),
+      ...meta
+    });
+  }
+
+  writeApiRequest(logFile, request) {
+    this.appendEntry(logFile, {
+      type: 'api_request',
+      timestamp: new Date().toISOString(),
+      ...request
+    });
+  }
+
+  writeApiResponse(logFile, response) {
+    this.appendEntry(logFile, {
+      type: 'api_response',
+      timestamp: new Date().toISOString(),
+      ...response
+    });
+  }
+
+  writeFileChange(logFile, change) {
+    this.appendEntry(logFile, {
+      type: 'file_change',
+      timestamp: new Date().toISOString(),
+      ...change
+    });
+  }
+}
+
+export function createLogManager(logDir) {
+  return new LogManager(logDir);
+}

package/src/lib/logger.js

@@ -0,0 +1,88 @@
+import { appendFileSync, existsSync, mkdirSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const LOG_DIR = resolve(__dirname, '../../logs');
+
+const LEVELS = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+};
+
+let sharedLogFile = null;
+let sharedInitDone = false;
+
+class Logger {
+  constructor(moduleName, level = 'INFO') {
+    this.moduleName = moduleName;
+    this.level = LEVELS[level] ?? LEVELS.INFO;
+  }
+
+  init() {
+    if (!sharedInitDone) {
+      if (!existsSync(LOG_DIR)) {
+        mkdirSync(LOG_DIR, { recursive: true });
+      }
+
+      const now = new Date();
+      const timestamp = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
+      sharedLogFile = join(LOG_DIR, `${timestamp}.txt`);
+
+      appendFileSync(sharedLogFile, `\n========== Session Started: ${now.toISOString()} ==========\n`);
+      sharedInitDone = true;
+    }
+  }
+
+  _format(level, message) {
+    const now = new Date();
+    const timestamp = now.toISOString();
+    return `[${timestamp}] [${level}] [${this.moduleName}] ${message}`;
+  }
+
+  _write(level, message) {
+    if (LEVELS[level] < this.level) return;
+
+    const formatted = this._format(level, message);
+
+    console.log(formatted);
+
+    if (sharedLogFile) {
+      try {
+        appendFileSync(sharedLogFile, formatted + '\n');
+      } catch (e) {
+        console.error('Failed to write to log file:', e);
+      }
+    }
+  }
+
+  debug(message) {
+    this._write('DEBUG', message);
+  }
+
+  info(message) {
+    this._write('INFO', message);
+  }
+
+  warn(message) {
+    this._write('WARN', message);
+  }
+
+  error(message) {
+    this._write('ERROR', message);
+  }
+
+  errorWithStack(message, error) {
+    const stack = error?.stack || error?.message || error || '';
+    this._write('ERROR', `${message}\n  ${stack}`);
+  }
+}
+
+export function createLogger(moduleName, level = 'INFO') {
+  const logger = new Logger(moduleName, level);
+  logger.init();
+  return logger;
+}

package/src/lib/sse-parser.js

@@ -0,0 +1,79 @@
+export function parseSSEStream(data) {
+  if (!data || typeof data !== 'string') {
+    return null;
+  }
+
+  const lines = data.split('\n');
+  const event = {
+    type: null,
+    data: null,
+    id: null,
+    retry: null
+  };
+
+  for (const line of lines) {
+    if (line.startsWith('event:')) {
+      event.type = line.slice(6).trim();
+    } else if (line.startsWith('data:')) {
+      const value = line.slice(5).trim();
+      try {
+        event.data = JSON.parse(value);
+      } catch {
+        event.data = value;
+      }
+    } else if (line.startsWith('id:')) {
+      event.id = line.slice(3).trim();
+    } else if (line.startsWith('retry:')) {
+      event.retry = parseInt(line.slice(7).trim(), 10);
+    }
+  }
+
+  if (event.type === 'null' && !event.data) {
+    return null;
+  }
+
+  return event;
+}
+
+export function parseSSELines(lines) {
+  const events = [];
+
+  for (const line of lines) {
+    const event = parseSSEStream(line);
+    if (event) {
+      events.push(event);
+    }
+  }
+
+  return events;
+}
+
+export function extractDelta(event) {
+  if (!event || !event.data) return null;
+
+  if (event.data.type === 'content_block_delta') {
+    return event.data.delta;
+  }
+
+  return null;
+}
+
+export function extractToolUse(event) {
+  if (!event || !event.data) return null;
+
+  if (event.data.type === 'tool_use') {
+    return event.data;
+  }
+
+  return null;
+}
+
+export function extractMessage(event) {
+  if (!event || !event.data) return null;
+
+  if (event.data.type === 'message') {
+    return event.data.message;
+  }
+
+  return null;
+}

package/src/main.jsx

@@ -0,0 +1,9 @@
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { App } from './components/App.jsx';
+import './global.css';
+
+const container = document.getElementById('root');
+const root = createRoot(container);
+
+root.render(<App />);

package/src/proxy.js

@@ -0,0 +1,156 @@
+import { createServer } from 'http';
+import { parseSSEStream } from './lib/sse-parser.js';
+import { createLogger } from './lib/logger.js';
+
+const DEFAULT_UPSTREAM = 'https://api.openai.com';
+const PROXY_PORT = 8080;
+
+const logger = createLogger('Proxy');
+
+export class ProxyServer {
+  constructor(wsEmitter, port = PROXY_PORT) {
+    this.port = port;
+    this.wsEmitter = wsEmitter;
+    this.server = null;
+  }
+
+  async start() {
+    return new Promise((resolve) => {
+      this.server = createServer(async (req, res) => {
+        const baseUrl = process.env.OPENAI_BASE_URL || DEFAULT_UPSTREAM;
+        const url = new URL(req.url, baseUrl);
+        const upstreamUrl = `${baseUrl}${url.pathname}${url.search}`;
+
+        logger.info(`Incoming request: ${req.method} ${upstreamUrl}`);
+
+        const headers = { ...req.headers };
+        delete headers.host;
+
+        const chunks = [];
+        for await (const chunk of req) {
+          chunks.push(chunk);
+        }
+        const body = chunks.length > 0 ? Buffer.concat(chunks) : null;
+
+        const requestData = {
+          timestamp: new Date().toISOString(),
+          method: req.method,
+          url: upstreamUrl,
+          headers: headers,
+          body: body ? JSON.parse(body.toString()) : null,
+        };
+
+        try {
+          logger.debug(`Forwarding to upstream: ${upstreamUrl}`);
+
+          const upstreamRes = await fetch(upstreamUrl, {
+            method: req.method,
+            headers: headers,
+            body: body,
+          });
+
+          this.wsEmitter({
+            type: 'api_request',
+            data: requestData,
+          });
+
+          const responseHeaders = {};
+          for (const [key, value] of upstreamRes.headers.entries()) {
+            if (key.toLowerCase() !== 'content-encoding' &&
+                key.toLowerCase() !== 'transfer-encoding') {
+              responseHeaders[key] = value;
+            }
+          }
+
+          const contentType = upstreamRes.headers.get('content-type') || '';
+          const isStreaming = contentType.includes('text/event-stream') ||
+                              contentType.includes('stream');
+
+          if (isStreaming) {
+            logger.debug('Streaming response detected');
+            res.writeHead(upstreamRes.status, responseHeaders);
+
+            const clonedRes = upstreamRes.body.clone();
+
+            this.parseStream(clonedRes, (event) => {
+              this.wsEmitter({ type: 'sse_event', data: event });
+            });
+
+            upstreamRes.body.pipe(res);
+          } else {
+            const responseBody = await upstreamRes.text();
+
+            this.wsEmitter({
+              type: 'api_response',
+              data: {
+                timestamp: new Date().toISOString(),
+                status: upstreamRes.status,
+                headers: responseHeaders,
+                body: responseBody,
+              },
+            });
+
+            logger.info(`Response received: ${upstreamRes.status}`);
+
+            res.writeHead(upstreamRes.status, responseHeaders);
+            res.end(responseBody);
+          }
+        } catch (error) {
+          logger.errorWithStack('Proxy error:', error);
+          res.writeHead(502, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: error.message }));
+        }
+      });
+
+      this.server.listen(this.port, () => {
+        logger.info(`Proxy server started on port ${this.port}`);
+        resolve(this.port);
+      });
+    });
+  }
+
+  parseStream(stream, onEvent) {
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    const reader = stream.getReader();
+
+    const read = () => {
+      reader.read().then(({ done, value }) => {
+        if (done) {
+          if (buffer.trim()) {
+            const event = parseSSEStream(buffer);
+            if (event) onEvent(event);
+          }
+          return;
+        }
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.trim()) {
+            const event = parseSSEStream(line);
+            if (event) onEvent(event);
+          }
+        }
+
+        read();
+      });
+    };
+
+    read();
+  }
+
+  stop() {
+    if (this.server) {
+      this.server.close();
+      logger.info('Proxy server stopped');
+    }
+  }
+}
+
+export function createProxyServer(wsEmitter, port) {
+  return new ProxyServer(wsEmitter, port);
+}

package/src/pty-manager.js

@@ -0,0 +1,183 @@
+import { fileURLToPath } from 'node:url';
+import { join, dirname } from 'node:path';
+import { platform, arch } from 'node:os';
+import { chmodSync, statSync } from 'node:fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+let ptyProcess = null;
+let dataListeners = [];
+let exitListeners = [];
+let lastExitCode = null;
+let outputBuffer = '';
+let lastPtyCols = 120;
+let lastPtyRows = 30;
+const MAX_BUFFER = 200000;
+let batchBuffer = '';
+let batchScheduled = false;
+
+async function getPty() {
+  const ptyMod = await import('node-pty');
+  return ptyMod.default || ptyMod;
+}
+
+function findSafeSliceStart(buf, rawStart) {
+  const scanLimit = Math.min(rawStart + 64, buf.length);
+  let i = rawStart;
+  while (i < scanLimit) {
+    const ch = buf.charCodeAt(i);
+    if (ch === 0x1b) {
+      let j = i + 1;
+      while (j < scanLimit && !((buf.charCodeAt(j) >= 0x40 && buf.charCodeAt(j) <= 0x7e) && j > i + 1)) {
+        j++;
+      }
+      if (j < scanLimit) {
+        return j + 1;
+      }
+      i = j;
+      continue;
+    }
+    if ((ch >= 0x20 && ch <= 0x3f)) {
+      i++;
+      continue;
+    }
+    break;
+  }
+  return i < buf.length ? i : rawStart;
+}
+
+function flushBatch() {
+  batchScheduled = false;
+  if (!batchBuffer) return;
+  const chunk = batchBuffer;
+  batchBuffer = '';
+  for (const cb of dataListeners) {
+    try { cb(chunk); } catch { }
+  }
+}
+
+function fixSpawnHelperPermissions() {
+  try {
+    const os = platform();
+    const cpu = arch();
+    const helperPath = join(__dirname, 'node_modules', 'node-pty', 'prebuilds', `${os}-${cpu}`, 'spawn-helper');
+    const stat = statSync(helperPath);
+    if (!(stat.mode & 0o111)) {
+      chmodSync(helperPath, stat.mode | 0o755);
+    }
+  } catch { }
+}
+
+export async function spawnCodex(codexBinary, projectRoot, proxyPort) {
+  if (ptyProcess) {
+    killPty();
+  }
+
+  const pty = await getPty();
+
+  fixSpawnHelperPermissions();
+
+  const shell = platform() === 'win32' ? 'powershell.exe' : 'bash';
+  const args = platform() === 'win32'
+    ? ['-NoExit', '-Command', `Set-Location "${projectRoot}"; & "${codexBinary}"`]
+    : [];
+
+  const env = { ...process.env };
+  env.OPENAI_BASE_URL = `http://127.0.0.1:${proxyPort}`;
+  if (platform() === 'win32') {
+    env.WINPTY = '1';
+  }
+
+  lastExitCode = null;
+  outputBuffer = '';
+
+  ptyProcess = pty.spawn(shell, args, {
+    name: 'xterm-256color',
+    cols: lastPtyCols,
+    rows: lastPtyRows,
+    cwd: projectRoot,
+    env,
+    useConpty: false,
+  });
+
+  ptyProcess.onData((data) => {
+    outputBuffer += data;
+    if (outputBuffer.length > MAX_BUFFER) {
+      const rawStart = outputBuffer.length - MAX_BUFFER;
+      const safeStart = findSafeSliceStart(outputBuffer, rawStart);
+      outputBuffer = outputBuffer.slice(safeStart);
+    }
+    batchBuffer += data;
+    if (!batchScheduled) {
+      batchScheduled = true;
+      setImmediate(flushBatch);
+    }
+  });
+
+  ptyProcess.onExit(({ exitCode }) => {
+    flushBatch();
+    lastExitCode = exitCode;
+    ptyProcess = null;
+    for (const cb of exitListeners) {
+      try { cb(exitCode); } catch { }
+    }
+  });
+
+  return ptyProcess;
+}
+
+export function writeToPty(data) {
+  if (ptyProcess) {
+    ptyProcess.write(data);
+    return true;
+  }
+  return false;
+}
+
+export function resizePty(cols, rows) {
+  lastPtyCols = cols;
+  lastPtyRows = rows;
+  if (ptyProcess) {
+    try { ptyProcess.resize(cols, rows); } catch { }
+  }
+}
+
+export function killPty() {
+  if (ptyProcess) {
+    flushBatch();
+    batchBuffer = '';
+    batchScheduled = false;
+    try { ptyProcess.kill(); } catch { }
+    ptyProcess = null;
+  }
+}
+
+export function onPtyData(cb) {
+  dataListeners.push(cb);
+  return () => {
+    dataListeners = dataListeners.filter(l => l !== cb);
+  };
+}
+
+export function onPtyExit(cb) {
+  exitListeners.push(cb);
+  return () => {
+    exitListeners = exitListeners.filter(l => l !== cb);
+  };
+}
+
+export function getPtyPid() {
+  return ptyProcess ? ptyProcess.pid : null;
+}
+
+export function getPtyState() {
+  return {
+    running: !!ptyProcess,
+    exitCode: lastExitCode,
+  };
+}
+
+export function getOutputBuffer() {
+  return outputBuffer;
+}