tidewave 0.5.4 → 0.6.0

package/dist/next-js/instrumentation.js

@@ -28,23 +28,31 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/logger/circular-buffer.ts
-class CircularBuffer {
-  buffer;
-  maxSize;
-  writeIndex = 0;
-  count = 0;
-  constructor(maxSize = 1024) {
-    this.buffer = new Array(maxSize);
-    this.maxSize = maxSize;
+// src/logger/tidewave-logger.ts
+import { appendFile, readFile } from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+import * as crypto from "crypto";
+
+class TidewaveLogger {
+  logFilePath;
+  constructor() {
+    const cwd = process.cwd();
+    const digest = crypto.createHash("md5").update(cwd).digest("hex").slice(0, 16);
+    const tempDir = os.tmpdir();
+    this.logFilePath = path.join(tempDir, `${digest}.tidewave.ndjson`);
   }
-  addLog(log) {
-    this.buffer[this.writeIndex] = log;
-    this.writeIndex = (this.writeIndex + 1) % this.maxSize;
-    this.count = Math.min(this.count + 1, this.maxSize);
+  async addLog(log) {
+    const line = JSON.stringify(log) + `
+`;
+    try {
+      await appendFile(this.logFilePath, line, "utf8");
+    } catch (error) {
+      console.log("[Tidewave] failed to write to log file, error:", error);
+    }
   }
-  getLogs(options) {
-    let logs = this.getAllLogs();
+  async getLogs(options) {
+    let logs = await this.getAllLogs();
     if (options?.level) {
       const level = options.level.toUpperCase();
       logs = logs.filter((log) => log.severityText === level);
@@ -62,34 +70,100 @@ class CircularBuffer {
     }
     return logs;
   }
-  getAllLogs() {
-    if (this.count < this.maxSize) {
-      return this.buffer.slice(0, this.count).filter(Boolean);
+  async getAllLogs() {
+    try {
+      const content = await readFile(this.logFilePath, "utf8");
+      return content.split(`
+`).map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter((log) => log !== null);
+    } catch (error) {
+      console.log("[Tidewave] failed to read from log file, error:", error);
+      return [];
     }
-    return [...this.buffer.slice(this.writeIndex), ...this.buffer.slice(0, this.writeIndex)].filter(Boolean);
   }
-  getStats() {
-    return {
-      totalLogs: this.count,
-      bufferSize: this.maxSize,
-      bufferUsage: Math.min(this.count / this.maxSize * 100, 100).toFixed(1) + "%"
-    };
+}
+var tidewaveLogger;
+var init_tidewave_logger = __esm(() => {
+  tidewaveLogger = new TidewaveLogger;
+});
+
+// src/logger/console-patch.ts
+var exports_console_patch = {};
+__export(exports_console_patch, {
+  patchConsole: () => patchConsole
+});
+function stripAnsiCodes(text) {
+  return text.replace(ANSI_REGEX, "");
+}
+function patchConsole() {
+  const isBrowser = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
+  if (isBrowser) {
+    return;
   }
-  clear() {
-    this.buffer = new Array(this.maxSize);
-    this.writeIndex = 0;
-    this.count = 0;
+  if (globalThis.__TIDEWAVE_CONSOLE_PATCHED__) {
+    return;
   }
+  const severityMap = {
+    log: "INFO",
+    info: "INFO",
+    warn: "WARN",
+    error: "ERROR",
+    debug: "DEBUG"
+  };
+  Object.entries(severityMap).forEach(([method, severity]) => {
+    const original = console[method].bind(console);
+    console[method] = (...args) => {
+      try {
+        const body = args.map((arg) => {
+          if (typeof arg === "string")
+            return arg;
+          if (arg instanceof Error) {
+            return String(arg.stack);
+          }
+          if (typeof arg === "object") {
+            try {
+              return JSON.stringify(arg);
+            } catch {
+              return String(arg);
+            }
+          }
+          return String(arg);
+        }).map(stripAnsiCodes).join(" ");
+        const isAllWhitespace = body.match(/^\s+$/);
+        if (!isAllWhitespace) {
+          tidewaveLogger.addLog({
+            timestamp: new Date().toISOString(),
+            severityText: severity,
+            body,
+            attributes: {
+              "log.origin": "console",
+              "log.method": method
+            }
+          });
+        }
+      } catch {}
+      original(...args);
+    };
+  });
+  globalThis.__TIDEWAVE_CONSOLE_PATCHED__ = true;
 }
-var circularBuffer;
-var init_circular_buffer = __esm(() => {
-  if (!globalThis.__tidewaveCircularBuffer) {
-    globalThis.__tidewaveCircularBuffer = new CircularBuffer(1024);
-  }
-  circularBuffer = globalThis.__tidewaveCircularBuffer;
+var ANSI_REGEX;
+var init_console_patch = __esm(() => {
+  init_tidewave_logger();
+  ANSI_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
 });
 
+// src/next-js/instrumentation.ts
+init_console_patch();
+
 // src/logger/tidewave-span-processor.ts
+init_tidewave_logger();
+
 class TidewaveSpanProcessor {
   onStart(_span, _parentContext) {}
   onEnd(span) {
@@ -108,8 +182,8 @@ class TidewaveSpanProcessor {
       const httpUrl = span.attributes["http.url"];
       const httpTarget = span.attributes["http.target"];
       const httpStatusCode = span.attributes["http.status_code"];
-      const path = route || httpTarget || httpUrl || "unknown";
-      if (typeof path === "string" && path.startsWith("/tidewave")) {
+      const path2 = route || httpTarget || httpUrl || "unknown";
+      if (typeof path2 === "string" && path2.startsWith("/tidewave")) {
         return;
       }
       const durationMs = this.calculateDuration(span);
@@ -118,7 +192,7 @@ class TidewaveSpanProcessor {
       if (spanType === "BaseServer.handleRequest") {
         const method = httpMethod || "UNKNOWN";
         const status = httpStatusCode || "unknown";
-        message = `${method} ${path} ${status} ${durationMs.toFixed(2)}ms`;
+        message = `${method} ${path2} ${status} ${durationMs.toFixed(2)}ms`;
         if (typeof httpStatusCode === "number") {
           if (httpStatusCode >= 500)
             severity = "ERROR";
@@ -130,7 +204,7 @@ class TidewaveSpanProcessor {
       } else if (spanType === "AppRouteRouteHandlers.runHandler") {
         message = `API route: ${route || "unknown"} (${durationMs.toFixed(2)}ms)`;
       }
-      circularBuffer.addLog({
+      tidewaveLogger.addLog({
         timestamp: new Date(span.endTime[0] * 1000 + span.endTime[1] / 1e6).toISOString(),
         severityText: severity,
         body: message,
@@ -155,100 +229,27 @@ class TidewaveSpanProcessor {
   async forceFlush() {}
   async shutdown() {}
 }
-var init_tidewave_span_processor = __esm(() => {
-  init_circular_buffer();
-});
-
 // src/logger/tidewave-log-record-processor.ts
+init_tidewave_logger();
+
 class TidewaveLogRecordProcessor {
   onEmit(logRecord, _context) {
     try {
       const body = String(logRecord.body || "");
-      circularBuffer.addLog({
+      tidewaveLogger.addLog({
         timestamp: new Date(logRecord.hrTime[0] * 1000 + logRecord.hrTime[1] / 1e6).toISOString(),
         severityText: logRecord.severityText || "INFO",
         body,
-        attributes: logRecord.attributes,
-        resource: logRecord.resource?.attributes
+        attributes: logRecord.attributes
       });
     } catch (_error) {}
   }
   async forceFlush() {}
   async shutdown() {}
 }
-var init_tidewave_log_record_processor = __esm(() => {
-  init_circular_buffer();
-});
-
-// src/logger/instrumentation.ts
-var exports_instrumentation = {};
-__export(exports_instrumentation, {
-  TidewaveSpanProcessor: () => TidewaveSpanProcessor,
-  TidewaveLogRecordProcessor: () => TidewaveLogRecordProcessor
-});
-function stripAnsiCodes(text) {
-  return text.replace(ANSI_REGEX, "");
-}
-function patchConsole() {
-  const isBrowser = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
-  if (isBrowser) {
-    return;
-  }
-  if (globalThis.__TIDEWAVE_CONSOLE_PATCHED__) {
-    return;
-  }
-  const severityMap = {
-    log: "INFO",
-    info: "INFO",
-    warn: "WARN",
-    error: "ERROR",
-    debug: "DEBUG"
-  };
-  Object.entries(severityMap).forEach(([method, severity]) => {
-    const original = console[method].bind(console);
-    console[method] = (...args) => {
-      try {
-        const body = args.map((arg) => {
-          if (typeof arg === "string")
-            return arg;
-          if (arg instanceof Error) {
-            return String(arg.stack);
-          }
-          if (typeof arg === "object") {
-            try {
-              return JSON.stringify(arg);
-            } catch {
-              return String(arg);
-            }
-          }
-          return String(arg);
-        }).map(stripAnsiCodes).join(" ");
-        circularBuffer.addLog({
-          timestamp: new Date().toISOString(),
-          severityText: severity,
-          body,
-          attributes: {
-            "log.origin": "console",
-            "log.method": method
-          }
-        });
-      } catch {}
-      original(...args);
-    };
-  });
-  globalThis.__TIDEWAVE_CONSOLE_PATCHED__ = true;
-}
-var ANSI_REGEX;
-var init_instrumentation = __esm(() => {
-  init_circular_buffer();
-  init_tidewave_span_processor();
-  init_tidewave_log_record_processor();
-  ANSI_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
-  patchConsole();
-});
 
 // src/next-js/instrumentation.ts
-init_instrumentation();
+patchConsole();
 export {
   TidewaveSpanProcessor,
   TidewaveLogRecordProcessor

package/dist/tanstack.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tanstack.js

@@ -0,0 +1,163 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/logger/tidewave-logger.ts
+import { appendFile, readFile } from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+import * as crypto from "crypto";
+
+class TidewaveLogger {
+  logFilePath;
+  constructor() {
+    const cwd = process.cwd();
+    const digest = crypto.createHash("md5").update(cwd).digest("hex").slice(0, 16);
+    const tempDir = os.tmpdir();
+    this.logFilePath = path.join(tempDir, `${digest}.tidewave.ndjson`);
+  }
+  async addLog(log) {
+    const line = JSON.stringify(log) + `
+`;
+    try {
+      await appendFile(this.logFilePath, line, "utf8");
+    } catch (error) {
+      console.log("[Tidewave] failed to write to log file, error:", error);
+    }
+  }
+  async getLogs(options) {
+    let logs = await this.getAllLogs();
+    if (options?.level) {
+      const level = options.level.toUpperCase();
+      logs = logs.filter((log) => log.severityText === level);
+    }
+    if (options?.since) {
+      const sinceDate = new Date(options.since);
+      logs = logs.filter((log) => new Date(log.timestamp) >= sinceDate);
+    }
+    if (options?.grep) {
+      const regex = new RegExp(options.grep, "i");
+      logs = logs.filter((log) => regex.test(log.body) || regex.test(JSON.stringify(log.attributes)));
+    }
+    if (options?.tail) {
+      logs = logs.slice(-options.tail);
+    }
+    return logs;
+  }
+  async getAllLogs() {
+    try {
+      const content = await readFile(this.logFilePath, "utf8");
+      return content.split(`
+`).map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter((log) => log !== null);
+    } catch (error) {
+      console.log("[Tidewave] failed to read from log file, error:", error);
+      return [];
+    }
+  }
+}
+var tidewaveLogger;
+var init_tidewave_logger = __esm(() => {
+  tidewaveLogger = new TidewaveLogger;
+});
+
+// src/logger/console-patch.ts
+var exports_console_patch = {};
+__export(exports_console_patch, {
+  patchConsole: () => patchConsole
+});
+function stripAnsiCodes(text) {
+  return text.replace(ANSI_REGEX, "");
+}
+function patchConsole() {
+  const isBrowser = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
+  if (isBrowser) {
+    return;
+  }
+  if (globalThis.__TIDEWAVE_CONSOLE_PATCHED__) {
+    return;
+  }
+  const severityMap = {
+    log: "INFO",
+    info: "INFO",
+    warn: "WARN",
+    error: "ERROR",
+    debug: "DEBUG"
+  };
+  Object.entries(severityMap).forEach(([method, severity]) => {
+    const original = console[method].bind(console);
+    console[method] = (...args) => {
+      try {
+        const body = args.map((arg) => {
+          if (typeof arg === "string")
+            return arg;
+          if (arg instanceof Error) {
+            return String(arg.stack);
+          }
+          if (typeof arg === "object") {
+            try {
+              return JSON.stringify(arg);
+            } catch {
+              return String(arg);
+            }
+          }
+          return String(arg);
+        }).map(stripAnsiCodes).join(" ");
+        const isAllWhitespace = body.match(/^\s+$/);
+        if (!isAllWhitespace) {
+          tidewaveLogger.addLog({
+            timestamp: new Date().toISOString(),
+            severityText: severity,
+            body,
+            attributes: {
+              "log.origin": "console",
+              "log.method": method
+            }
+          });
+        }
+      } catch {}
+      original(...args);
+    };
+  });
+  globalThis.__TIDEWAVE_CONSOLE_PATCHED__ = true;
+}
+var ANSI_REGEX;
+var init_console_patch = __esm(() => {
+  init_tidewave_logger();
+  ANSI_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+});
+
+// src/tanstack.ts
+init_console_patch();
+patchConsole();

package/dist/tools.d.ts

@@ -28,18 +28,18 @@ export interface Tools {
 }
 export declare const projectEvalInputSchema: z.ZodObject<{
     code: z.ZodString;
-    arguments: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodAny, "many">>>;
+    arguments: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>>;
     timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     json: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
     code: string;
     timeout: number;
-    arguments: any[];
+    arguments: unknown[];
     json: boolean;
 }, {
     code: string;
     timeout?: number | undefined;
-    arguments?: any[] | undefined;
+    arguments?: unknown[] | undefined;
     json?: boolean | undefined;
 }>;
 export declare const docsInputSchema: z.ZodObject<{

package/dist/vite-plugin.d.ts

@@ -1,4 +1,3 @@
 import type { TidewaveConfig } from './core';
 import type { Plugin } from 'vite';
-import './logger/instrumentation';
 export default function tidewave(config?: TidewaveConfig): Plugin;