@illuma-ai/code-sandbox 1.4.0 → 1.5.0

package/src/services/runtime.ts

@@ -1,775 +0,0 @@
-/**
- * NodepodRuntime — Manages the full lifecycle of a Nodepod sandbox.
- *
- * Flow: boot → write files → npm install → run entry command → track changes
- *
- * This is the core service that bridges project files and the browser runtime.
- * It is framework-agnostic (no React) — consumed by the useRuntime hook.
- */
-
-import { Nodepod } from "@illuma-ai/nodepod";
-import type { NodepodProcess } from "@illuma-ai/nodepod";
-import type {
-  BootProgress,
-  BootStage,
-  FileMap,
-  RuntimeConfig,
-  SandboxError,
-  SandboxErrorCategory,
-} from "../types";
-
-/** Callback type for progress updates */
-type ProgressCallback = (progress: BootProgress) => void;
-/** Callback type for terminal output lines */
-type OutputCallback = (line: string) => void;
-/** Callback type for server ready */
-type ServerReadyCallback = (port: number, url: string) => void;
-/** Callback type for structured errors */
-type ErrorCallback = (error: SandboxError) => void;
-
-/** Debug log prefix for easy filtering in DevTools console */
-const DBG = "[CodeSandbox:Runtime]";
-
-/**
- * Manages the Nodepod runtime lifecycle.
- *
- * Responsibilities:
- * - Boot Nodepod with COOP/COEP-compatible service worker
- * - Write project files into the virtual filesystem
- * - Install npm dependencies from package.json
- * - Start the entry command (e.g., "node server.js")
- * - Track file modifications for diffing
- * - Provide preview URL for the iframe
- */
-export class NodepodRuntime {
-  private nodepod: Nodepod | null = null;
-  private serverProcess: NodepodProcess | null = null;
-  private config: RuntimeConfig;
-  private originalFiles: FileMap = {};
-  private currentFiles: FileMap = {};
-  private terminalOutput: string[] = [];
-  private status: BootStage = "initializing";
-  private error: string | null = null;
-  private previewUrl: string | null = null;
-  private errors: SandboxError[] = [];
-  private errorIdCounter = 0;
-
-  // Callbacks
-  private onProgress: ProgressCallback | null = null;
-  private onOutput: OutputCallback | null = null;
-  private onServerReady: ServerReadyCallback | null = null;
-  private onSandboxError: ErrorCallback | null = null;
-
-  constructor(config: RuntimeConfig) {
-    this.config = {
-      workdir: "/app",
-      port: 3000,
-      ...config,
-    };
-    console.log(DBG, "constructor", {
-      workdir: this.config.workdir,
-      port: this.config.port,
-      entryCommand: this.config.entryCommand,
-      fileCount: Object.keys(this.config.files).length,
-      files: Object.keys(this.config.files),
-    });
-  }
-
-  /** Register a progress callback */
-  setProgressCallback(cb: ProgressCallback): void {
-    this.onProgress = cb;
-  }
-
-  /** Register a terminal output callback */
-  setOutputCallback(cb: OutputCallback): void {
-    this.onOutput = cb;
-  }
-
-  /** Register a server ready callback */
-  setServerReadyCallback(cb: ServerReadyCallback): void {
-    this.onServerReady = cb;
-  }
-
-  /** Register a structured error callback */
-  setErrorCallback(cb: ErrorCallback): void {
-    this.onSandboxError = cb;
-  }
-
-  /** Get the current preview URL (null if server not ready) */
-  getPreviewUrl(): string | null {
-    return this.previewUrl;
-  }
-
-  /** Get current status */
-  getStatus(): BootStage {
-    return this.status;
-  }
-
-  /** Get all terminal output */
-  getTerminalOutput(): string[] {
-    return [...this.terminalOutput];
-  }
-
-  /** Get current files (with edits applied) */
-  getCurrentFiles(): FileMap {
-    return { ...this.currentFiles };
-  }
-
-  /** Get the original files (as loaded, before any edits) */
-  getOriginalFiles(): FileMap {
-    return { ...this.originalFiles };
-  }
-
-  /** Get only the files that have been modified since loading */
-  getChangedFiles(): FileMap {
-    const changes: FileMap = {};
-    for (const [path, content] of Object.entries(this.currentFiles)) {
-      if (this.originalFiles[path] !== content) {
-        changes[path] = content;
-      }
-    }
-    return changes;
-  }
-
-  /** Get the error message if status is 'error' */
-  getError(): string | null {
-    return this.error;
-  }
-
-  /** Get all structured errors collected during this session */
-  getErrors(): SandboxError[] {
-    return [...this.errors];
-  }
-
-  /**
-   * Report an external error (e.g., from the preview iframe).
-   *
-   * This is the public entry point for errors that originate outside
-   * the runtime — browser console errors, unhandled rejections, etc.
-   * The runtime enriches them with source context from the virtual FS
-   * and emits them via the onSandboxError callback.
-   */
-  async reportError(error: SandboxError): Promise<void> {
-    // Enrich with source context if we have a file path and line number
-    if (error.filePath && error.line && !error.sourceContext) {
-      error.sourceContext = await this.getSourceContext(
-        error.filePath,
-        error.line,
-      );
-    }
-    this.errors.push(error);
-    this.onSandboxError?.(error);
-  }
-
-  // -------------------------------------------------------------------------
-  // Lifecycle
-  // -------------------------------------------------------------------------
-
-  /**
-   * Boot the runtime: initialize Nodepod → write files → install → start server.
-   *
-   * This is the main entry point. Call this once.
-   * The progress callback will fire at each stage.
-   */
-  async boot(): Promise<void> {
-    const t0 = performance.now();
-    console.log(DBG, "boot() started");
-
-    try {
-      // Stage 1: Initialize Nodepod
-      this.emitProgress("initializing", "Booting runtime environment...", 5);
-
-      const port = this.config.port ?? 3000;
-      console.log(DBG, "boot: calling Nodepod.boot()", {
-        swUrl: "/__sw__.js",
-        workdir: this.config.workdir,
-        port,
-      });
-
-      // Check preconditions Nodepod will check
-      console.log(
-        DBG,
-        "boot: SharedArrayBuffer available?",
-        typeof SharedArrayBuffer !== "undefined",
-      );
-      console.log(
-        DBG,
-        "boot: Worker available?",
-        typeof Worker !== "undefined",
-      );
-
-      const tBoot = performance.now();
-      this.nodepod = await Nodepod.boot({
-        swUrl: "/__sw__.js",
-        workdir: this.config.workdir,
-        env: this.config.env,
-        onServerReady: (readyPort: number, url: string) => {
-          console.log(DBG, "onServerReady fired!", {
-            readyPort,
-            url,
-            expectedPort: port,
-          });
-          if (readyPort === port) {
-            this.previewUrl = this.rewritePreviewUrl(url);
-            console.log(DBG, "previewUrl set to:", this.previewUrl);
-            this.emitProgress("ready", "Application is running", 100);
-            this.onServerReady?.(readyPort, this.previewUrl);
-          }
-        },
-      });
-      console.log(
-        DBG,
-        `boot: Nodepod.boot() completed in ${(performance.now() - tBoot).toFixed(0)}ms`,
-      );
-
-      this.emitProgress("initializing", "Runtime environment ready", 15);
-
-      // Stage 2: Write project files
-      this.emitProgress("writing-files", "Writing project files...", 20);
-      const tFiles = performance.now();
-      await this.writeFiles(this.config.files);
-      console.log(
-        DBG,
-        `boot: writeFiles completed in ${(performance.now() - tFiles).toFixed(0)}ms`,
-      );
-      this.emitProgress(
-        "writing-files",
-        `Wrote ${Object.keys(this.config.files).length} files`,
-        35,
-      );
-
-      // Verify files were actually written
-      try {
-        const workdir = this.config.workdir ?? "/app";
-        const testFile = Object.keys(this.config.files)[0];
-        if (testFile) {
-          const fullPath = testFile.startsWith("/")
-            ? testFile
-            : `${workdir}/${testFile}`;
-          const exists = await this.nodepod.fs.exists(fullPath);
-          console.log(DBG, `boot: verify file "${fullPath}" exists:`, exists);
-          if (exists) {
-            const content = await this.nodepod.fs.readFile(fullPath, "utf-8");
-            console.log(
-              DBG,
-              `boot: verify file "${fullPath}" has ${content.length} chars`,
-            );
-          }
-        }
-      } catch (verifyErr) {
-        console.warn(DBG, "boot: file verification failed:", verifyErr);
-      }
-
-      // Stage 3: Install dependencies (if package.json exists)
-      if (this.config.files["package.json"]) {
-        this.emitProgress("installing", "Installing dependencies...", 40);
-        const tInstall = performance.now();
-        await this.installDependencies();
-        console.log(
-          DBG,
-          `boot: installDependencies completed in ${(performance.now() - tInstall).toFixed(0)}ms`,
-        );
-        this.emitProgress("installing", "Dependencies installed", 70);
-      } else {
-        console.log(DBG, "boot: no package.json found, skipping install");
-      }
-
-      // Stage 4: Start the entry command
-      this.emitProgress("starting", "Starting application...", 75);
-      const tStart = performance.now();
-      await this.startServer();
-      console.log(
-        DBG,
-        `boot: startServer returned in ${(performance.now() - tStart).toFixed(0)}ms`,
-      );
-      console.log(
-        DBG,
-        `boot: total elapsed ${(performance.now() - t0).toFixed(0)}ms, status=${this.status}`,
-      );
-
-      // Note: 'ready' is emitted by the onServerReady callback above.
-      // If the server doesn't register a port (e.g., non-HTTP scripts),
-      // we mark ready after a short delay.
-      // Also poll more aggressively: check at 1s, 3s, 5s, 10s
-      const fallbackDelays = [1000, 3000, 5000, 10000];
-      for (const delay of fallbackDelays) {
-        setTimeout(() => {
-          if (this.status === "starting") {
-            // Check if we got a preview URL via port registration
-            const url = this.nodepod?.port(port);
-            console.log(
-              DBG,
-              `boot: fallback check @${delay}ms, port(${port}) =`,
-              url,
-              "status =",
-              this.status,
-            );
-            if (url) {
-              this.previewUrl = this.rewritePreviewUrl(url);
-              console.log(DBG, "fallback: previewUrl set to:", this.previewUrl);
-              this.emitProgress("ready", "Application is running", 100);
-              this.onServerReady?.(port, this.previewUrl);
-            } else if (delay === fallbackDelays[fallbackDelays.length - 1]) {
-              // Last check - report failure
-              console.error(
-                DBG,
-                "boot: server never became ready after 10s. Process state:",
-                {
-                  processExited: this.serverProcess?.exited,
-                  previewUrl: this.previewUrl,
-                  status: this.status,
-                },
-              );
-              this.appendOutput(
-                "[system] Server did not start within 10 seconds. Check the logs above for errors.",
-              );
-            }
-          }
-        }, delay);
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      const stack = err instanceof Error ? err.stack : undefined;
-      console.error(DBG, "boot: FATAL ERROR:", err);
-      this.error = message;
-      this.emitProgress("error", `Error: ${message}`, 0);
-      this.emitError("boot", message, { stack });
-      throw err;
-    }
-  }
-
-  /**
-   * Write a single file to the virtual filesystem.
-   * Used for editor changes after boot.
-   */
-  async writeFile(path: string, content: string): Promise<void> {
-    if (!this.nodepod) {
-      throw new Error("Runtime not booted");
-    }
-
-    const fullPath = this.resolvePath(path);
-    await this.nodepod.fs.writeFile(fullPath, content);
-    this.currentFiles[path] = content;
-  }
-
-  /**
-   * Read a file from the virtual filesystem.
-   */
-  async readFile(path: string): Promise<string> {
-    if (!this.nodepod) {
-      throw new Error("Runtime not booted");
-    }
-    const fullPath = this.resolvePath(path);
-    return await this.nodepod.fs.readFile(fullPath, "utf-8");
-  }
-
-  /**
-   * Restart the server process.
-   * Kills the current process and re-runs the entry command.
-   */
-  async restart(): Promise<void> {
-    if (this.serverProcess && !this.serverProcess.exited) {
-      this.serverProcess.kill();
-      // Wait for the process to exit
-      await this.serverProcess.completion.catch(() => {});
-    }
-    this.previewUrl = null;
-    this.emitProgress("starting", "Restarting application...", 75);
-    await this.startServer();
-  }
-
-  /**
-   * Tear down the runtime.
-   * Kills all processes and releases resources.
-   */
-  teardown(): void {
-    if (this.serverProcess && !this.serverProcess.exited) {
-      this.serverProcess.kill();
-    }
-    this.nodepod?.teardown();
-    this.nodepod = null;
-    this.serverProcess = null;
-    this.previewUrl = null;
-    this.status = "initializing";
-    this.terminalOutput = [];
-  }
-
-  /** Get raw Nodepod instance for advanced usage */
-  getNodepod(): Nodepod | null {
-    return this.nodepod;
-  }
-
-  // -------------------------------------------------------------------------
-  // Private helpers
-  // -------------------------------------------------------------------------
-
-  /**
-   * Rewrite a Nodepod virtual server URL to use /__preview__/ instead of /__virtual__/.
-   *
-   * WHY: Nodepod's serverUrl() returns /__virtual__/{port} URLs, but the
-   * Service Worker only tracks iframe client IDs for /__preview__/{port}
-   * navigations. Without client tracking, subresource requests (JS, CSS,
-   * API calls) from the preview iframe are NOT intercepted by the SW —
-   * they fall through to the real dev server and 404.
-   */
-  private rewritePreviewUrl(url: string): string {
-    return url.replace("/__virtual__/", "/__preview__/");
-  }
-
-  /** Resolve a relative path against the workdir */
-  private resolvePath(relativePath: string): string {
-    const workdir = this.config.workdir ?? "/app";
-    // Normalize: remove leading ./ and ensure proper path joining
-    const clean = relativePath.replace(/^\.\//, "");
-    if (clean.startsWith("/")) {
-      return clean;
-    }
-    return `${workdir}/${clean}`;
-  }
-
-  /** Write all project files to the virtual filesystem */
-  private async writeFiles(files: FileMap): Promise<void> {
-    if (!this.nodepod) {
-      return;
-    }
-
-    // Store originals for change tracking
-    this.originalFiles = { ...files };
-    this.currentFiles = { ...files };
-
-    // Write files in parallel batches of 10
-    const entries = Object.entries(files);
-    const batchSize = 10;
-
-    for (let i = 0; i < entries.length; i += batchSize) {
-      const batch = entries.slice(i, i + batchSize);
-      await Promise.all(
-        batch.map(([path, content]) => {
-          const fullPath = this.resolvePath(path);
-          return this.nodepod!.fs.writeFile(fullPath, content);
-        }),
-      );
-
-      // Update progress within the writing-files stage
-      const percent = 20 + Math.round((i / entries.length) * 15);
-      this.emitProgress(
-        "writing-files",
-        `Writing files... (${Math.min(i + batchSize, entries.length)}/${entries.length})`,
-        percent,
-      );
-    }
-  }
-
-  /**
-   * Install npm dependencies by spawning `npm install` in Nodepod.
-   *
-   * Nodepod's DependencyInstaller handles this internally via its
-   * package registry. We spawn `node -e` with a require to trigger it,
-   * or use the built-in npm install mechanism.
-   */
-  private async installDependencies(): Promise<void> {
-    if (!this.nodepod) {
-      return;
-    }
-
-    const workdir = this.config.workdir ?? "/app";
-
-    try {
-      // Parse package.json to find dependencies
-      const pkgJsonContent = this.config.files["package.json"];
-      if (!pkgJsonContent) {
-        return;
-      }
-
-      const pkgJson = JSON.parse(pkgJsonContent);
-      const deps = {
-        ...(pkgJson.dependencies || {}),
-        ...(pkgJson.devDependencies || {}),
-      };
-
-      const depNames = Object.keys(deps);
-      if (depNames.length === 0) {
-        return;
-      }
-
-      this.appendOutput(`Installing ${depNames.length} dependencies...`);
-
-      // Use Nodepod's built-in package installer for each dependency
-      for (let i = 0; i < depNames.length; i++) {
-        const dep = depNames[i];
-        const version = deps[dep];
-        const specifier = version
-          ? `${dep}@${version.replace(/[\^~>=<]/g, "")}`
-          : dep;
-
-        try {
-          await this.nodepod.packages.install(specifier);
-          this.appendOutput(`  ✓ ${dep}`);
-        } catch (err) {
-          this.appendOutput(
-            `  ✗ ${dep}: ${err instanceof Error ? err.message : err}`,
-          );
-        }
-
-        // Update progress
-        const percent = 40 + Math.round((i / depNames.length) * 30);
-        this.emitProgress(
-          "installing",
-          `Installing ${dep}... (${i + 1}/${depNames.length})`,
-          percent,
-        );
-      }
-
-      this.appendOutput("Dependencies installed.");
-    } catch (err) {
-      this.appendOutput(`Warning: Could not parse package.json: ${err}`);
-    }
-  }
-
-  /** Start the entry command (e.g., "node server.js") */
-  private async startServer(): Promise<void> {
-    if (!this.nodepod) {
-      return;
-    }
-
-    const workdir = this.config.workdir ?? "/app";
-    const command = this.config.entryCommand;
-
-    // Parse the command: "node server.js" → cmd="node", args=["server.js"]
-    const parts = command.split(/\s+/);
-    const cmd = parts[0];
-    const args = parts.slice(1);
-
-    this.appendOutput(`\n$ ${command}`);
-
-    this.serverProcess = await this.nodepod.spawn(cmd, args, { cwd: workdir });
-
-    this.serverProcess.on("output", (chunk: string) => {
-      this.appendOutput(chunk);
-    });
-
-    this.serverProcess.on("error", (chunk: string) => {
-      this.appendOutput(`[stderr] ${chunk}`);
-      // Emit structured error for stderr output.
-      // Filter out noise: skip empty lines and common non-error warnings.
-      const trimmed = chunk.trim();
-      if (trimmed && !this.isStderrNoise(trimmed)) {
-        this.emitError("process-stderr", trimmed);
-      }
-    });
-
-    this.serverProcess.on("exit", (code: number) => {
-      this.appendOutput(`\nProcess exited with code ${code}`);
-      if (code !== 0 && this.status !== "ready") {
-        this.error = `Process exited with code ${code}`;
-        this.emitProgress("error", `Process exited with code ${code}`, 0);
-        // Emit structured error for non-zero exit
-        this.emitError("process-exit", `Process exited with code ${code}`, {
-          // Include last 20 lines of terminal output for context
-          stack: this.terminalOutput.slice(-20).join("\n"),
-        });
-      }
-    });
-  }
-
-  /** Emit a progress update */
-  private emitProgress(
-    stage: BootStage,
-    message: string,
-    percent: number,
-  ): void {
-    this.status = stage;
-    const progress: BootProgress = { stage, message, percent };
-    this.onProgress?.(progress);
-  }
-
-  /** Append a line to terminal output */
-  private appendOutput(line: string): void {
-    this.terminalOutput.push(line);
-    this.onOutput?.(line);
-  }
-
-  // -------------------------------------------------------------------------
-  // Error helpers
-  // -------------------------------------------------------------------------
-
-  /** Generate a unique error ID */
-  private nextErrorId(): string {
-    return `err_${++this.errorIdCounter}_${Date.now()}`;
-  }
-
-  /**
-   * Create and record a structured error from a process or boot event.
-   *
-   * Parses the error message to extract file path and line number when
-   * possible, then enriches with surrounding source context.
-   */
-  private async emitError(
-    category: SandboxErrorCategory,
-    message: string,
-    extra?: Partial<SandboxError>,
-  ): Promise<void> {
-    // Parse file/line from common Node.js error formats:
-    // - "/app/server.js:42"
-    // - "at Object.<anonymous> (/app/routes/api.js:15:8)"
-    // - "SyntaxError: /app/server.js: Unexpected token (12:5)"
-    let filePath = extra?.filePath;
-    let line = extra?.line;
-    let column = extra?.column;
-
-    if (!filePath) {
-      const parsed = this.parseErrorLocation(message + (extra?.stack ?? ""));
-      filePath = parsed.filePath;
-      line = parsed.line ?? line;
-      column = parsed.column ?? column;
-    }
-
-    let sourceContext = extra?.sourceContext;
-    if (filePath && line && !sourceContext) {
-      sourceContext = await this.getSourceContext(filePath, line);
-    }
-
-    const error: SandboxError = {
-      id: this.nextErrorId(),
-      category,
-      message,
-      timestamp: new Date().toISOString(),
-      ...extra,
-      filePath,
-      line,
-      column,
-      sourceContext,
-    };
-
-    this.errors.push(error);
-    this.onSandboxError?.(error);
-  }
-
-  /**
-   * Filter out common non-error stderr output.
-   *
-   * Many Node.js tools write informational messages to stderr
-   * (deprecation warnings, experimental feature notices, etc.).
-   * We don't want to flood the agent with these.
-   */
-  private isStderrNoise(text: string): boolean {
-    const noisePatterns = [
-      /^DeprecationWarning:/,
-      /^ExperimentalWarning:/,
-      /^\(node:\d+\) /,
-      /^npm WARN /,
-      /^warn /i,
-      /^Debugger listening/,
-      /^Debugger attached/,
-      /^Waiting for the debugger/,
-    ];
-    return noisePatterns.some((p) => p.test(text));
-  }
-
-  /**
-   * Parse file path and line/column from common error message formats.
-   *
-   * Handles:
-   * - Node.js stack frames: "at func (/app/file.js:12:5)"
-   * - Direct references: "/app/file.js:12:5"
-   * - SyntaxError: "/app/file.js: Unexpected token (12:5)"
-   */
-  private parseErrorLocation(text: string): {
-    filePath?: string;
-    line?: number;
-    column?: number;
-  } {
-    const workdir = this.config.workdir ?? "/app";
-
-    // Pattern 1: "at ... (/app/path/file.js:LINE:COL)"
-    const stackMatch = text.match(/\(?(\/[^:)]+):(\d+):(\d+)\)?/);
-    if (stackMatch) {
-      const absPath = stackMatch[1];
-      const relativePath = absPath.startsWith(workdir + "/")
-        ? absPath.slice(workdir.length + 1)
-        : absPath;
-      return {
-        filePath: relativePath,
-        line: parseInt(stackMatch[2], 10),
-        column: parseInt(stackMatch[3], 10),
-      };
-    }
-
-    // Pattern 2: "file.js:LINE" (no column)
-    const simpleMatch = text.match(/\(?(\/[^:)]+):(\d+)\)?/);
-    if (simpleMatch) {
-      const absPath = simpleMatch[1];
-      const relativePath = absPath.startsWith(workdir + "/")
-        ? absPath.slice(workdir.length + 1)
-        : absPath;
-      return {
-        filePath: relativePath,
-        line: parseInt(simpleMatch[2], 10),
-      };
-    }
-
-    // Pattern 3: "Unexpected token (LINE:COL)" with a file path earlier
-    const syntaxMatch = text.match(/(\/[^\s:]+)\s*:\s*[^(]*\((\d+):(\d+)\)/);
-    if (syntaxMatch) {
-      const absPath = syntaxMatch[1];
-      const relativePath = absPath.startsWith(workdir + "/")
-        ? absPath.slice(workdir.length + 1)
-        : absPath;
-      return {
-        filePath: relativePath,
-        line: parseInt(syntaxMatch[2], 10),
-        column: parseInt(syntaxMatch[3], 10),
-      };
-    }
-
-    return {};
-  }
-
-  /**
-   * Get surrounding source code lines from the virtual filesystem.
-   *
-   * Returns ~10 lines centered on the target line, formatted as
-   * "lineNum: content" for each line. This gives the AI agent enough
-   * context to construct a surgical fix.
-   */
-  private async getSourceContext(
-    filePath: string,
-    targetLine: number,
-    windowSize = 5,
-  ): Promise<string | undefined> {
-    try {
-      const content = this.currentFiles[filePath];
-      if (!content) {
-        // Try reading from the FS directly (file might have been written
-        // outside of our tracking, e.g., by npm install)
-        if (!this.nodepod) return undefined;
-        const fullPath = this.resolvePath(filePath);
-        const exists = await this.nodepod.fs.exists(fullPath);
-        if (!exists) return undefined;
-        const fsContent = await this.nodepod.fs.readFile(fullPath, "utf-8");
-        return this.formatSourceContext(fsContent, targetLine, windowSize);
-      }
-      return this.formatSourceContext(content, targetLine, windowSize);
-    } catch {
-      return undefined;
-    }
-  }
-
-  /**
-   * Format source code lines centered on a target line.
-   * Output: "lineNum: content\n" for each line in the window.
-   */
-  private formatSourceContext(
-    content: string,
-    targetLine: number,
-    windowSize: number,
-  ): string {
-    const lines = content.split("\n");
-    const start = Math.max(0, targetLine - windowSize - 1);
-    const end = Math.min(lines.length, targetLine + windowSize);
-    return lines
-      .slice(start, end)
-      .map((l, i) => `${start + i + 1}: ${l}`)
-      .join("\n");
-  }
-}