@tonyclaw/llm-inspector 1.8.0 → 1.9.1

package/src/proxy/formats/anthropic/stream.ts

@@ -133,6 +133,17 @@ export function extractAnthropicStream(
           stopSequence = data.delta.stop_sequence ?? null;
           outputTokens = data.usage.output_tokens;
           log.outputTokens = outputTokens;
+          // Cache tokens may also be present in message_delta usage
+          if (data.usage.cache_creation_input_tokens !== undefined) {
+            log.cacheCreationInputTokens = data.usage.cache_creation_input_tokens;
+          }
+          if (data.usage.cache_read_input_tokens !== undefined) {
+            log.cacheReadInputTokens = data.usage.cache_read_input_tokens;
+          }
+          break;
+        case "error":
+          // Store error info on the log for display
+          log.error = data.error.message;
           break;
         case "content_block_stop":
         case "message_stop":

package/src/proxy/formats/openai/stream.ts

@@ -42,6 +42,21 @@ export function extractOpenAIStream(
 
     try {
       const parsed: unknown = JSON.parse(dataStr);
+      // Check for error object in SSE stream before trying to parse as chunk
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        const errorDesc = Object.getOwnPropertyDescriptor(parsed, "error");
+        if (
+          errorDesc !== undefined &&
+          typeof errorDesc.value === "object" &&
+          errorDesc.value !== null
+        ) {
+          const msgDesc = Object.getOwnPropertyDescriptor(errorDesc.value, "message");
+          if (msgDesc !== undefined && typeof msgDesc.value === "string") {
+            log.error = msgDesc.value;
+          }
+          continue;
+        }
+      }
       const chunkResult = OpenAISSERawChunkSchema.safeParse(parsed);
       if (!chunkResult.success) continue;
       const chunk = chunkResult.data;

package/src/proxy/handler.ts

@@ -1,5 +1,5 @@
 import { createLog, emitLogUpdate, type CapturedLog } from "./store";
-import { appendLogEntry } from "./logger";
+import { appendLogEntry, initLogger, logger } from "./logger";
 import { writeChunks } from "./chunkStorage";
 import { extractModelFromBody, type RequestFormat } from "./schemas";
 import { registry } from "./formats";
@@ -28,6 +28,16 @@ import {
   STATUS_BAD_GATEWAY,
 } from "./constants";
 
+// Initialize logger at startup
+initLogger()
+  .then(() => {
+    logger.info("Proxy handler initialized");
+  })
+  .catch((err) => {
+    // eslint-disable-next-line no-console
+    console.error("[handler] Logger initialization failed:", err);
+  });
+
 /**
  * Strips all custom/non-standard headers from the request and replaces with
  * unified proxy identity. Only preserves standard HTTP headers needed for API calls.
@@ -89,6 +99,7 @@ function buildFileLogEntry(log: CapturedLog, upstreamUrl: string): Record<string
     clientProjectFolder: log.clientProjectFolder,
     streamingChunks: log.streamingChunks,
     streamingChunksPath: log.streamingChunksPath,
+    error: log.error,
   };
 }
 
@@ -252,7 +263,7 @@ function handleStreamingResponse(
         );
         log.streamingChunksPath = chunkPath;
       }
-      appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: null });
+      appendLogEntry(buildFileLogEntry(log, upstreamUrl));
       emitLogUpdate(log);
     },
   });
@@ -264,18 +275,23 @@ function handleStreamingResponse(
   const loggedStream = upstreamRes.body.pipeThrough(transform);
 
   req.signal?.addEventListener("abort", () => {
-    if (log.responseText === null && chunks.length > 0) {
-      const full = chunks.join("");
+    if (log.responseText === null) {
+      logger.info(`[handler] Streaming client aborted: ${log.method} ${log.path}`);
       log.elapsedMs = Date.now() - startTime;
-      log.responseText = formatHandler.extractStream(full, log, log.model ?? undefined, true);
-      // Persist chunks to disk on abort
-      if (log.streamingChunks && log.streamingChunks.chunks.length > 0) {
-        const chunkPath = writeChunks(
-          log.id,
-          log.streamingChunks.chunks,
-          log.streamingChunks.truncated,
-        );
-        log.streamingChunksPath = chunkPath;
+      if (chunks.length > 0) {
+        const full = chunks.join("");
+        log.responseText = formatHandler.extractStream(full, log, log.model ?? undefined, true);
+        // Persist chunks to disk on abort
+        if (log.streamingChunks && log.streamingChunks.chunks.length > 0) {
+          const chunkPath = writeChunks(
+            log.id,
+            log.streamingChunks.chunks,
+            log.streamingChunks.truncated,
+          );
+          log.streamingChunksPath = chunkPath;
+        }
+      } else {
+        log.responseText = "Client aborted";
       }
       appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: "Client aborted" });
       emitLogUpdate(log);
@@ -296,15 +312,17 @@ export async function handleProxy(req: Request): Promise<Response> {
   const url = new URL(req.url);
   const parsed = parseRequestPath(req, url);
 
+  // Read body only after cheap path checks
   let requestBody: string | null = null;
   if (req.body && req.method !== "GET" && req.method !== "HEAD") {
     requestBody = await req.text();
   }
 
-  // Extract model once and reuse
+  // Extract model once and reuse - avoid duplicate parsing
   const model = requestBody !== null ? extractModelFromBody(requestBody) : null;
 
-  const matchedProviderConfig = findProviderByModelFromConfig(requestBody);
+  // Find provider config using already-extracted model (not calling extractModelFromBody again)
+  const matchedProviderConfig = model !== null ? findProviderByModel(model) : null;
   const upstreamBase = selectUpstreamBase(parsed.isChatCompletions, matchedProviderConfig);
   const upstreamUrl = buildUpstreamUrl(upstreamBase, parsed.normalizedPath);
   const upstreamHost = getHostFromUrl(upstreamBase);
@@ -318,6 +336,7 @@ export async function handleProxy(req: Request): Promise<Response> {
 
   // Only proxy requests matching a registered provider
   if (model === null || provider === null) {
+    logger.warn(`[handler] Unsupported provider: model=${model}`);
     return new Response("Forbidden: unsupported provider", { status: STATUS_FORBIDDEN });
   }
 
@@ -354,9 +373,19 @@ export async function handleProxy(req: Request): Promise<Response> {
       method: req.method,
       headers: upstreamHeaders,
       body: requestBody,
+      signal: req.signal,
     });
   } catch (err) {
     log.elapsedMs = Date.now() - startTime;
+    // Check if it was a client abort (not a proxy error)
+    if (err instanceof Error && err.name === "AbortError") {
+      logger.info(`[handler] Client aborted: ${req.method} ${parsed.apiPath}`);
+      log.responseStatus = 499; // Client Closed Request (non-standard but descriptive)
+      log.responseText = "Client aborted";
+      appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: "Client aborted" });
+      return new Response("Client aborted", { status: 499 });
+    }
+    logger.error(`[handler] Proxy error: ${req.method} ${parsed.apiPath}`, String(err));
     log.responseStatus = STATUS_BAD_GATEWAY;
     log.responseText = String(err);
     appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: String(err) });
@@ -380,15 +409,3 @@ export async function handleProxy(req: Request): Promise<Response> {
 
   return handleStreamingResponse(upstreamRes, req, startTime, formatHandler, upstreamUrl, log);
 }
-
-/**
- * Find provider configuration by model name (from persistent store).
- */
-function findProviderByModelFromConfig(
-  requestBody: string | null,
-): ReturnType<typeof findProviderByModel> {
-  if (requestBody === null) return null;
-  const model = extractModelFromBody(requestBody);
-  if (model === null) return null;
-  return findProviderByModel(model);
-}

package/src/proxy/logIndex.ts

@@ -2,7 +2,7 @@ import { readFile, writeFile, stat, readdir, mkdir } from "node:fs/promises";
 import { createReadStream, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { createInterface } from "node:readline";
-import { resolveLogDir } from "./logger";
+import { resolveLogDir, logger } from "./logger";
 
 type LogIndexEntry = {
   id: number;
@@ -71,8 +71,7 @@ export async function loadIndex(): Promise<LogIndex> {
     }
     return cachedIndex;
   } catch (err) {
-    // eslint-disable-next-line no-console
-    console.error("[logIndex] Failed to load index:", err);
+    logger.error("[logIndex] Failed to load index:", String(err));
     cachedIndex = createEmptyIndex();
     return cachedIndex;
   }
@@ -91,8 +90,7 @@ export async function saveIndex(index: LogIndex): Promise<void> {
   try {
     await writeFile(indexPath, JSON.stringify(index), "utf-8");
   } catch (err) {
-    // eslint-disable-next-line no-console
-    console.error("[logIndex] Failed to save index:", err);
+    logger.error("[logIndex] Failed to save index:", String(err));
   }
 }
 
@@ -107,6 +105,36 @@ export async function addToIndex(
   if (id > index.maxId) {
     index.maxId = id;
   }
+  // Defer disk writes to reduce I/O - flush after a batch of updates
+  scheduleIndexFlush();
+}
+
+// Batch writes: collect pending flushes and write once
+let indexFlushScheduled = false;
+let indexFlushTimeout: ReturnType<typeof setTimeout> | null = null;
+
+async function flushIndexAsync(): Promise<void> {
+  indexFlushScheduled = false;
+  indexFlushTimeout = null;
+  const index = await loadIndex();
+  await saveIndex(index);
+}
+
+function scheduleIndexFlush(): void {
+  if (indexFlushScheduled) return;
+  indexFlushScheduled = true;
+  indexFlushTimeout = setTimeout(() => {
+    void flushIndexAsync();
+  }, 1000); // Flush after 1 second of inactivity
+}
+
+export async function flushIndex(): Promise<void> {
+  if (indexFlushTimeout !== null) {
+    clearTimeout(indexFlushTimeout);
+    indexFlushTimeout = null;
+  }
+  indexFlushScheduled = false;
+  const index = await loadIndex();
   await saveIndex(index);
 }
 
@@ -173,9 +201,47 @@ export async function rebuildIndex(): Promise<LogIndex> {
   return newIndex;
 }
 
+// Async mutex for atomic ID generation to prevent race conditions
+// Uses a promise queue instead of busy-waiting
+let idGenerationPromise: Promise<void> | null = null;
+let releaseLock: (() => void) | null = null;
+
+async function acquireLock(): Promise<void> {
+  if (releaseLock === null) {
+    idGenerationPromise = new Promise<void>((resolve) => {
+      releaseLock = resolve;
+    });
+  } else {
+    // Wait for the previous lock to be released
+    await idGenerationPromise;
+    // After waiting, we need to create a new promise for the next waiter
+    idGenerationPromise = new Promise<void>((resolve) => {
+      releaseLock = resolve;
+    });
+  }
+}
+
+function releaseLockFn(): void {
+  if (releaseLock) {
+    const resolve = releaseLock;
+    releaseLock = null;
+    idGenerationPromise = null;
+    resolve();
+  }
+}
+
 export async function getNextLogId(): Promise<number> {
-  const index = await loadIndex();
-  return index.maxId + 1;
+  await acquireLock();
+  try {
+    const index = await loadIndex();
+    const nextId = index.maxId + 1;
+    index.maxId = nextId;
+    // Synchronously update the index in memory (disk write is deferred via batching)
+    cachedIndex = index;
+    return nextId;
+  } finally {
+    releaseLockFn();
+  }
 }
 
 export function getCurrentLogFile(): string {

package/src/proxy/logger.ts

@@ -3,6 +3,7 @@ import path from "node:path";
 
 const LOG_DIR_ENV = process.env["LOG_DIR"];
 const RETENTION_DAYS = Number(process.env["LOG_RETENTION_DAYS"] ?? "7");
+const LOG_FILE_ENV = process.env["LLM_INSPECTOR_LOG_FILE"];
 
 function getUserDataDir(): string {
   if (process.platform === "win32") {
@@ -35,6 +36,14 @@ export function getLogFilePath(): string {
   return path.join(resolveLogDir(), `${yyyy}-${mm}-${dd}.jsonl`);
 }
 
+function getInspectorLogPath(): string {
+  if (LOG_FILE_ENV !== undefined) {
+    return LOG_FILE_ENV;
+  }
+  const base = getUserDataDir();
+  return path.join(base, ".llm-inspector", "logs", "inspector.log");
+}
+
 export async function initLogger(): Promise<void> {
   const dir = resolveLogDir();
   const retentionMs = RETENTION_DAYS * 24 * 60 * 60 * 1000;
@@ -50,24 +59,63 @@ export async function initLogger(): Promise<void> {
         if (s.mtimeMs < cutoff) {
           await unlink(fullPath);
         }
-      } catch (err) {
-        // eslint-disable-next-line no-console
-        console.error("[logger] Failed to stat/remove log file:", err);
+      } catch {
+        // Skip files that can't be stat - not critical
       }
     }
   } catch (err) {
+    // Log directory initialization errors but don't fail startup
+    // eslint-disable-next-line no-console
+    console.error("[logger] Failed to initialize log directory:", err);
+  }
+}
+
+// File-based logger for application logs (not log entries)
+async function writeAppLog(message: string): Promise<void> {
+  try {
+    const logPath = getInspectorLogPath();
+    const logDirPath = path.dirname(logPath);
+    await mkdir(logDirPath, { recursive: true });
+    const timestamp = new Date().toISOString();
+    await appendFile(logPath, `[${timestamp}] ${message}\n`, "utf-8");
+  } catch (err) {
+    // Log to stderr since file logging failed
     // eslint-disable-next-line no-console
-    console.error("[logger] Failed to initialize logger:", err);
+    console.error(`[logger] Failed to write to ${getInspectorLogPath()}:`, err);
   }
 }
 
+// Application logger - writes to inspector.log
+export const logger = {
+  debug(message: string, ...args: unknown[]): void {
+    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    void writeAppLog(`[DEBUG] ${msg}`);
+  },
+  info(message: string, ...args: unknown[]): void {
+    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    void writeAppLog(`[INFO] ${msg}`);
+  },
+  warn(message: string, ...args: unknown[]): void {
+    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    void writeAppLog(`[WARN] ${msg}`);
+  },
+  error(message: string, ...args: unknown[]): void {
+    const msg = args.length > 0 ? `${message} ${args.map(String).join(" ")}` : message;
+    void writeAppLog(`[ERROR] ${msg}`);
+  },
+};
+
 // Write buffer for batching async writes
+const MAX_BUFFER_SIZE = 1000; // Prevent unbounded memory growth
 let writeBuffer: string[] = [];
 let writeScheduled = false;
+let isFlushing = false; // Prevent concurrent flush operations
 
 async function flushWriteBuffer(): Promise<void> {
   if (writeBuffer.length === 0) return;
+  if (isFlushing) return; // Skip if another flush is in progress
 
+  isFlushing = true;
   const toWrite = writeBuffer.join("");
   writeBuffer = [];
 
@@ -76,8 +124,11 @@ async function flushWriteBuffer(): Promise<void> {
     await mkdir(path.dirname(filePath), { recursive: true });
     await appendFile(filePath, toWrite, "utf-8");
   } catch (err) {
+    // Log write buffer errors but don't throw to prevent cascading failures
     // eslint-disable-next-line no-console
-    console.error("[logger] Failed to write log entries:", err);
+    console.error("[logger] Failed to flush write buffer:", err);
+  } finally {
+    isFlushing = false;
   }
 }
 
@@ -95,5 +146,10 @@ function scheduleFlush(): void {
 export function appendLogEntry(entry: Record<string, unknown>): void {
   const line = JSON.stringify(entry) + "\n";
   writeBuffer.push(line);
-  scheduleFlush();
+  // Flush immediately if buffer exceeds max size to prevent OOM
+  if (writeBuffer.length >= MAX_BUFFER_SIZE) {
+    void flushWriteBuffer();
+  } else {
+    scheduleFlush();
+  }
 }

package/src/proxy/providers.ts

@@ -17,6 +17,8 @@ export const ProviderConfigSchema = z.object({
   openaiBaseUrl: z.string().optional(),
   /** Auth header to use: "bearer" (default) or "x-api-key" */
   authHeader: z.enum(["bearer", "x-api-key"]).optional().default("bearer"),
+  /** API documentation URL */
+  apiDocsUrl: z.string().optional(),
   createdAt: z.string(),
   updatedAt: z.string(),
 });
@@ -142,6 +144,7 @@ export function addProvider(
   baseUrl?: string,
   model?: string,
   authHeader?: "bearer" | "x-api-key",
+  apiDocsUrl?: string,
 ): ProviderConfig {
   const providers = getProviders();
   const now = new Date().toISOString();
@@ -153,6 +156,7 @@ export function addProvider(
     baseUrl,
     model,
     authHeader: authHeader ?? "bearer",
+    apiDocsUrl,
     createdAt: now,
     updatedAt: now,
     anthropicBaseUrl: format === "anthropic" && baseUrl !== undefined ? baseUrl : "",
@@ -179,6 +183,7 @@ export function updateProvider(
     format: updates.format ?? existing.format,
     baseUrl: updates.baseUrl !== undefined ? updates.baseUrl : existing.baseUrl,
     authHeader: updates.authHeader ?? existing.authHeader,
+    apiDocsUrl: updates.apiDocsUrl ?? existing.apiDocsUrl,
     createdAt: existing.createdAt,
     updatedAt: new Date().toISOString(),
     // Handle format-specific URLs

package/src/proxy/schemas.ts

@@ -61,6 +61,8 @@ export const CapturedLogSchema = z.object({
   clientProjectFolder: z.string().nullable().optional(),
   streamingChunks: StreamingChunksArraySchema.optional(),
   streamingChunksPath: z.string().nullable().optional(),
+  /** Error message from streaming response (e.g., SSE error event) */
+  error: z.string().nullable().optional(),
 });
 
 export type CapturedLog = z.infer<typeof CapturedLogSchema>;

package/src/proxy/socketTracker.ts

@@ -1,5 +1,6 @@
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
+import { logger } from "./logger";
 
 const execAsync = promisify(exec);
 
@@ -55,30 +56,49 @@ function extractRemotePort(request: Request): number | null {
 }
 
 /**
- * Look up PID from a local port using netstat.
+ * Look up PID from a local port using platform-appropriate command.
  * Returns PID as number, or null if not found.
  */
 async function lookupPidByPort(port: number): Promise<number | null> {
+  const platform = process.platform;
+
   try {
-    // netstat -aon finds all connections with port, -n avoids DNS resolution
-    // Filter by ESTABLISHED connections on the specific port
-    const { stdout } = await execAsync(`netstat -aon | findstr :${port} | findstr ESTABLISHED`, {
-      windowsHide: true,
-    });
-
-    const lines = stdout.trim().split("\n").filter(Boolean);
-    for (const line of lines) {
-      // Format: TCP    127.0.0.1:12345    127.0.0.1:54321    ESTABLISHED    12345
-      // The last space-separated token is the PID
-      const parts = line.trim().split(/\s+/);
-      const lastPart = parts[parts.length - 1];
-      if (lastPart !== undefined) {
-        const pid = parseInt(lastPart, 10);
+    if (platform === "win32") {
+      // Windows: use PowerShell Get-NetTCPConnection (faster than netstat)
+      const { stdout } = await execAsync(
+        `powershell -NoProfile -Command "Get-NetTCPConnection -LocalPort ${port} -State Established | Select-Object -ExpandProperty OwningProcess"`,
+        { windowsHide: true },
+      );
+      const pid = parseInt(stdout.trim(), 10);
+      return !isNaN(pid) && pid > 0 ? pid : null;
+    } else if (platform === "darwin") {
+      // macOS: use lsof
+      const { stdout } = await execAsync(`lsof -i :${port} -sTCP:ESTABLISHED -t 2>/dev/null`, {
+        shell: "/bin/sh",
+      });
+      const pid = parseInt(stdout.trim(), 10);
+      return !isNaN(pid) && pid > 0 ? pid : null;
+    } else {
+      // Linux: use ss (faster than netstat) or fall back to netstat
+      try {
+        const { stdout } = await execAsync(
+          `ss -tlnp 'sport = :${port}' 2>/dev/null | grep ESTAB | awk '{print $6}' | grep -o 'pid=[0-9]*' | cut -d= -f2`,
+          { shell: "/bin/sh" },
+        );
+        const pid = parseInt(stdout.trim(), 10);
         if (!isNaN(pid) && pid > 0) return pid;
+      } catch {
+        // Fall back to netstat
       }
+      const { stdout } = await execAsync(
+        `netstat -tan 2>/dev/null | grep ':${port}' | grep ESTABLISHED | awk '{print $7}' | cut -d/ -f1`,
+        { shell: "/bin/sh" },
+      );
+      const pid = parseInt(stdout.trim(), 10);
+      return !isNaN(pid) && pid > 0 ? pid : null;
     }
-    return null;
-  } catch {
+  } catch (err) {
+    logger.debug(`[socketTracker] Failed to lookup PID for port ${port}:`, String(err));
     return null;
   }
 }
@@ -90,35 +110,69 @@ async function lookupPidByPort(port: number): Promise<number | null> {
 async function lookupProcessInfo(
   pid: number,
 ): Promise<{ cwd: string | null; projectFolder: string | null }> {
+  const platform = process.platform;
+
   try {
-    // Use wmic to get the full command line
-    const { stdout } = await execAsync(
-      `wmic process where processid=${pid} get commandline /value`,
-      { windowsHide: true },
-    );
-
-    const lines = stdout.trim().split("\n").filter(Boolean);
-    for (const line of lines) {
-      if (line.includes("=")) {
-        const commandLine = (line.split("=")[1] ?? "").trim();
+    if (platform === "win32") {
+      // Windows: use wmic
+      const { stdout } = await execAsync(
+        `wmic process where processid=${pid} get commandline /value`,
+        { windowsHide: true },
+      );
+
+      const lines = stdout.trim().split("\n").filter(Boolean);
+      for (const line of lines) {
+        if (line.includes("=")) {
+          const commandLine = (line.split("=")[1] ?? "").trim();
+          if (commandLine) {
+            const exeMatch = commandLine.match(/^"([^"]+)"/) || commandLine.match(/^([^\s]+)/);
+            if (exeMatch && exeMatch[1] !== undefined) {
+              const exePath = exeMatch[1];
+              const exeDir = exePath.substring(0, exePath.lastIndexOf("\\"));
+              return {
+                cwd: exeDir,
+                projectFolder: exeDir.split("\\").pop() ?? null,
+              };
+            }
+          }
+        }
+      }
+    } else {
+      // Unix/Linux/macOS: read from /proc or use ps
+      try {
+        // Try reading /proc/PID/cmdline (Linux)
+        const { stdout } = await execAsync(`cat /proc/${pid}/cmdline 2>/dev/null | tr '\\0' ' '`, {
+          shell: "/bin/sh",
+        });
+        const commandLine = stdout.trim();
         if (commandLine) {
-          // Extract CWD from command line
-          // The command typically looks like: "C:\path\to\ai-tool\resources\app\bin\cli\win32-x64\tool.exe" ...
-          // or "C:\Users\user\AppData\Local\Programs\Claude\Claude.exe" --some-flag
-          // We need to find the working directory - it's usually the directory containing the exe
-          // but we also need to check if a --parent-dir flag was passed
-
-          // Parse the command line to find the executable path
           const exeMatch = commandLine.match(/^"([^"]+)"/) || commandLine.match(/^([^\s]+)/);
           if (exeMatch && exeMatch[1] !== undefined) {
             const exePath = exeMatch[1];
-            const exeDir = exePath.substring(0, exePath.lastIndexOf("\\"));
+            const exeDir = exePath.substring(0, exePath.lastIndexOf("/"));
             return {
               cwd: exeDir,
-              projectFolder: exeDir.split("\\").pop() ?? null,
+              projectFolder: exeDir.split("/").pop() ?? null,
             };
           }
         }
+      } catch {
+        // Fall back to ps
+      }
+
+      // macOS fallback
+      if (platform === "darwin") {
+        const { stdout } = await execAsync(`ps -p ${pid} -o comm= 2>/dev/null`, {
+          shell: "/bin/sh",
+        });
+        const exePath = stdout.trim();
+        if (exePath) {
+          const exeDir = exePath.substring(0, exePath.lastIndexOf("/"));
+          return {
+            cwd: exeDir,
+            projectFolder: exePath.split("/").pop() ?? null,
+          };
+        }
       }
     }
     return { cwd: null, projectFolder: null };