codex-lens 0.1.0 → 0.1.2

package/build.js

@@ -18,9 +18,12 @@ async function buildAll() {
     'src/proxy.js',
     'src/aggregator.js',
     'src/watcher.js',
+    'src/pty-manager.js',
+    'src/snapshot-manager.js',
     'src/lib/sse-parser.js',
     'src/lib/diff-builder.js',
     'src/lib/log-manager.js',
+    'src/lib/logger.js',
   ];
 
   for (const file of backendFiles) {

package/dist/lib/logger.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+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 = /* @__PURE__ */ new Date();
+      const timestamp = now.toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      sharedLogFile = join(LOG_DIR, `${timestamp}.txt`);
+      appendFileSync(sharedLogFile, `
+========== Session Started: ${now.toISOString()} ==========
+`);
+      sharedInitDone = true;
+    }
+  }
+  _format(level, message) {
+    const now = /* @__PURE__ */ 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}
+  ${stack}`);
+  }
+}
+function createLogger(moduleName, level = "INFO") {
+  const logger = new Logger(moduleName, level);
+  logger.init();
+  return logger;
+}
+export {
+  createLogger
+};

package/dist/pty-manager.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+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 = 2e5;
+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 === 27) {
+      let j = i + 1;
+      while (j < scanLimit && !(buf.charCodeAt(j) >= 64 && buf.charCodeAt(j) <= 126 && j > i + 1)) {
+        j++;
+      }
+      if (j < scanLimit) {
+        return j + 1;
+      }
+      i = j;
+      continue;
+    }
+    if (ch >= 32 && ch <= 63) {
+      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 & 73)) {
+      chmodSync(helperPath, stat.mode | 493);
+    }
+  } catch {
+  }
+}
+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;
+}
+function writeToPty(data) {
+  if (ptyProcess) {
+    ptyProcess.write(data);
+    return true;
+  }
+  return false;
+}
+function resizePty(cols, rows) {
+  lastPtyCols = cols;
+  lastPtyRows = rows;
+  if (ptyProcess) {
+    try {
+      ptyProcess.resize(cols, rows);
+    } catch {
+    }
+  }
+}
+function killPty() {
+  if (ptyProcess) {
+    flushBatch();
+    batchBuffer = "";
+    batchScheduled = false;
+    try {
+      ptyProcess.kill();
+    } catch {
+    }
+    ptyProcess = null;
+  }
+}
+function onPtyData(cb) {
+  dataListeners.push(cb);
+  return () => {
+    dataListeners = dataListeners.filter((l) => l !== cb);
+  };
+}
+function onPtyExit(cb) {
+  exitListeners.push(cb);
+  return () => {
+    exitListeners = exitListeners.filter((l) => l !== cb);
+  };
+}
+function getPtyPid() {
+  return ptyProcess ? ptyProcess.pid : null;
+}
+function getPtyState() {
+  return {
+    running: !!ptyProcess,
+    exitCode: lastExitCode
+  };
+}
+function getOutputBuffer() {
+  return outputBuffer;
+}
+export {
+  getOutputBuffer,
+  getPtyPid,
+  getPtyState,
+  killPty,
+  onPtyData,
+  onPtyExit,
+  resizePty,
+  spawnCodex,
+  writeToPty
+};

package/dist/snapshot-manager.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, statSync, readdirSync, mkdirSync, cpSync, rmSync, existsSync } from "fs";
+import { join, relative, extname } from "path";
+import { createLogger } from "./lib/logger.js";
+const logger = createLogger("SnapshotManager");
+const IGNORED_DIRS = [
+  "node_modules",
+  ".git",
+  ".svn",
+  ".hg",
+  ".idea",
+  ".vscode",
+  "dist",
+  "build",
+  ".cache",
+  "__pycache__",
+  ".pytest_cache",
+  ".next",
+  ".nuxt",
+  ".venv",
+  ".env",
+  ".DS_Store",
+  ".codex-viewer"
+];
+const IGNORED_FILES = [
+  ".DS_Store",
+  "Thumbs.db",
+  "desktop.ini"
+];
+const IGNORED_EXTENSIONS = [
+  ".log",
+  ".lock"
+];
+class SnapshotManager {
+  constructor(snapshotsDir = ".codex-viewer/snapshots") {
+    this.snapshotsDir = snapshotsDir;
+  }
+  async createSnapshot(projectRoot, taskId) {
+    const snapshotPath = join(this.snapshotsDir, taskId);
+    const metadataPath = join(snapshotPath, "snapshot.json");
+    logger.info(`Creating snapshot: ${taskId}`);
+    try {
+      if (!existsSync(this.snapshotsDir)) {
+        mkdirSync(this.snapshotsDir, { recursive: true });
+      }
+      if (existsSync(snapshotPath)) {
+        rmSync(snapshotPath, { recursive: true, force: true });
+      }
+      mkdirSync(snapshotPath, { recursive: true });
+      const files = this.scanProjectFiles(projectRoot);
+      const metadata = {
+        taskId,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        projectRoot,
+        filesCount: files.length,
+        files: []
+      };
+      for (const file of files) {
+        const relativePath = relative(projectRoot, file);
+        const destPath = join(snapshotPath, relativePath);
+        const destDir = join(snapshotPath, relative(projectRoot, join(file, "..")));
+        if (!existsSync(destDir)) {
+          mkdirSync(destDir, { recursive: true });
+        }
+        try {
+          cpSync(file, destPath, { force: true });
+          const stats = statSync(file);
+          metadata.files.push({
+            path: relativePath,
+            size: stats.size,
+            mtime: stats.mtime.toISOString()
+          });
+        } catch (err) {
+          logger.warn(`Failed to copy file ${file}: ${err.message}`);
+        }
+      }
+      writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+      logger.info(`Snapshot created: ${taskId}, ${files.length} files`);
+      return { success: true, snapshotPath, filesCount: files.length };
+    } catch (error) {
+      logger.error(`Failed to create snapshot: ${error.message}`);
+      return { success: false, error: error.message };
+    }
+  }
+  async restoreSnapshot(taskId) {
+    const snapshotPath = join(this.snapshotsDir, taskId);
+    const metadataPath = join(snapshotPath, "snapshot.json");
+    logger.info(`Restoring snapshot: ${taskId}`);
+    try {
+      if (!existsSync(snapshotPath)) {
+        return { success: false, error: "Snapshot not found" };
+      }
+      if (!existsSync(metadataPath)) {
+        return { success: false, error: "Snapshot metadata not found" };
+      }
+      const metadata = JSON.parse(readFileSync(metadataPath, "utf-8"));
+      const projectRoot = metadata.projectRoot;
+      let restoredCount = 0;
+      for (const fileInfo of metadata.files) {
+        const sourcePath = join(snapshotPath, fileInfo.path);
+        const destPath = join(projectRoot, fileInfo.path);
+        if (!existsSync(sourcePath)) {
+          continue;
+        }
+        const destDir = join(projectRoot, fileInfo.path.replace(/[^/\\]+$/, ""));
+        if (!existsSync(destDir)) {
+          mkdirSync(destDir, { recursive: true });
+        }
+        try {
+          cpSync(sourcePath, destPath, { force: true });
+          restoredCount++;
+        } catch (err) {
+          logger.warn(`Failed to restore file ${fileInfo.path}: ${err.message}`);
+        }
+      }
+      logger.info(`Snapshot restored: ${taskId}, ${restoredCount} files`);
+      return { success: true, restoredCount };
+    } catch (error) {
+      logger.error(`Failed to restore snapshot: ${error.message}`);
+      return { success: false, error: error.message };
+    }
+  }
+  async deleteSnapshot(taskId) {
+    const snapshotPath = join(this.snapshotsDir, taskId);
+    logger.info(`Deleting snapshot: ${taskId}`);
+    try {
+      if (existsSync(snapshotPath)) {
+        rmSync(snapshotPath, { recursive: true, force: true });
+        logger.info(`Snapshot deleted: ${taskId}`);
+        return { success: true };
+      }
+      return { success: false, error: "Snapshot not found" };
+    } catch (error) {
+      logger.error(`Failed to delete snapshot: ${error.message}`);
+      return { success: false, error: error.message };
+    }
+  }
+  getSnapshot(taskId) {
+    const snapshotPath = join(this.snapshotsDir, taskId);
+    const metadataPath = join(snapshotPath, "snapshot.json");
+    if (!existsSync(metadataPath)) {
+      return null;
+    }
+    try {
+      return JSON.parse(readFileSync(metadataPath, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  listSnapshots() {
+    try {
+      if (!existsSync(this.snapshotsDir)) {
+        return [];
+      }
+      const entries = readdirSync(this.snapshotsDir, { withFileTypes: true });
+      const snapshots = [];
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const metadata = this.getSnapshot(entry.name);
+          if (metadata) {
+            snapshots.push(metadata);
+          }
+        }
+      }
+      return snapshots.sort(
+        (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+      );
+    } catch (error) {
+      logger.error(`Failed to list snapshots: ${error.message}`);
+      return [];
+    }
+  }
+  scanProjectFiles(projectRoot) {
+    const files = [];
+    const scan = (dir) => {
+      try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = join(dir, entry.name);
+          if (entry.isDirectory()) {
+            if (!IGNORED_DIRS.includes(entry.name) && !entry.name.startsWith(".")) {
+              scan(fullPath);
+            }
+          } else if (entry.isFile()) {
+            if (IGNORED_FILES.includes(entry.name)) {
+              continue;
+            }
+            if (IGNORED_EXTENSIONS.some((ext) => entry.name.endsWith(ext))) {
+              continue;
+            }
+            files.push(fullPath);
+          }
+        }
+      } catch (err) {
+        logger.warn(`Failed to scan directory ${dir}: ${err.message}`);
+      }
+    };
+    scan(projectRoot);
+    return files;
+  }
+}
+function createSnapshotManager(snapshotsDir) {
+  return new SnapshotManager(snapshotsDir);
+}
+export {
+  SnapshotManager,
+  createSnapshotManager
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-lens",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "A visualization tool for Codex that monitors API requests and file system changes with task snapshot rollback",
   "license": "MIT",
   "type": "module",