tidewave 0.5.5 → 0.7.0

package/dist/core.d.ts

@@ -19,7 +19,7 @@ export interface InternalResolvedModule {
 }
 export interface ExtractionRequest {
     readonly module: string;
-    readonly symbol: string;
+    readonly symbol?: string;
     readonly member?: string;
     readonly isStatic?: boolean;
 }
@@ -32,6 +32,18 @@ export interface SymbolInfo {
     readonly location: string;
     readonly jsDoc?: string;
 }
+export interface ExportSummary {
+    readonly name: string;
+    readonly kind: string;
+    readonly line: number;
+    readonly documentation?: string;
+}
+export interface FileInfo {
+    readonly path: string;
+    readonly overview?: string;
+    readonly exportCount: number;
+    readonly exports: ExportSummary[];
+}
 export interface ExtractorOptions {
     readonly prefix?: string;
 }
@@ -62,19 +74,16 @@ export interface EvaluatedModuleResult {
     stderr: string;
 }
 export type ResolveResult = ResolvedModule | ResolveError;
-export type ExtractResult = SymbolInfo | ExtractError;
+export type ExtractResult = SymbolInfo | FileInfo | ExtractError;
 export type InternalResolveResult = InternalResolvedModule | ResolveError;
-export declare function isError(result: ResolveResult | ExtractResult): boolean;
 export declare function isResolveError(result: ResolveResult | InternalResolveResult): result is ResolveError;
 export declare function isExtractError(result: ExtractResult): result is ExtractError;
+export declare function isFileInfo(result: ExtractResult): result is FileInfo;
 export declare function resolveError(specifier: ModuleRequest['specifier'], source: ModuleRequest['source']): ResolveError;
 export declare function createExtractError(code: ExtractError['error']['code'], message: string, details?: unknown): ExtractError;
 export interface TidewaveConfig {
-    port?: number;
-    host?: string;
     clientUrl?: string;
     allowRemoteAccess?: boolean;
-    allowedOrigins?: string[];
     projectName?: string;
     framework?: string;
     team?: {

package/dist/http/handlers/config.d.ts

@@ -1,3 +1,4 @@
-import type { Handler } from '../index';
+import { type Request, type Handler } from '../index';
 import type { TidewaveConfig } from '../../core';
-export declare function createHandleConfig(config: TidewaveConfig): Handler;
+export type LocalPortGetter = (req: Request) => number | undefined;
+export declare function createHandleConfig(config: TidewaveConfig, getLocalPort?: LocalPortGetter): Handler;

package/dist/http/index.d.ts

@@ -1,5 +1,6 @@
 import type { ServerResponse } from 'http';
 import type { IncomingMessage, NextFunction, Server } from 'connect';
+import { type LocalPortGetter } from './handlers/config';
 import type { TidewaveConfig } from '../core';
 export interface Request extends IncomingMessage {
     body?: Record<string, unknown>;
@@ -8,9 +9,12 @@ export type Response = ServerResponse<IncomingMessage>;
 export type NextFn = NextFunction;
 export declare const ENDPOINT: "/tidewave";
 export type Handler = (req: Request, res: Response, next: NextFn) => Promise<void>;
-declare function getHandlers(config: TidewaveConfig): Record<string, Handler>;
-export declare function configureServer(server?: Server, config?: TidewaveConfig): Server;
-export declare function serve(server: Server, config?: TidewaveConfig): void;
+export interface HandlerOptions {
+    getLocalPort?: LocalPortGetter;
+}
+declare function getHandlers(config: TidewaveConfig, options?: HandlerOptions): Record<string, Handler>;
+export declare function configureServer(server?: Server, config?: TidewaveConfig, options?: HandlerOptions): Server;
 export declare function checkSecurity(config: TidewaveConfig): (req: Request, res: Response, next: NextFn) => void;
 export declare function methodNotAllowed(res: Response): void;
+export declare function originNotAllowed(res: Response): void;
 export { getHandlers };

package/dist/http/security.d.ts

@@ -2,11 +2,3 @@ import type { TidewaveConfig } from '../core';
 import type { Request, Response } from './index';
 export declare function checkRemoteIp(req: Request, res: Response, config: TidewaveConfig): boolean;
 export declare function isLocalIp(ip?: string): boolean;
-export declare function checkOrigin(req: Request, res: Response, config: TidewaveConfig): boolean;
-export declare function getDefaultAllowedOrigins(config: TidewaveConfig): string[];
-export declare function parseUrl(url: string): {
-    scheme?: string;
-    host: string;
-    port?: number;
-} | null;
-export declare function isOriginAllowed(origin: ReturnType<typeof parseUrl>, allowed: ReturnType<typeof parseUrl>): boolean;

package/dist/logger/console-patch.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Patch console methods to write directly to the tidewave logger.
+ * This is called automatically when this module is imported.
+ */
+export declare function patchConsole(): void;

package/dist/logger/tidewave-log-record-processor.d.ts

@@ -2,7 +2,7 @@ import type { LogRecordProcessor, SdkLogRecord } from '@opentelemetry/sdk-logs';
 import type { Context } from '@opentelemetry/api';
 /**
  * Custom LogRecordProcessor that captures OpenTelemetry logger logs
- * and writes them directly to the circular buffer.
+ * and writes them directly to the tidewave logger.
  *
  * This is opt-in for users who want to capture actual logger logs
  * (not console.log, which is handled separately by console patching).

package/dist/logger/tidewave-logger.d.ts

@@ -0,0 +1,37 @@
+export interface StoredLogRecord {
+    timestamp: string;
+    severityText: string;
+    body: string;
+    attributes?: Record<string, unknown>;
+}
+export interface LogFilterOptions {
+    tail?: number;
+    grep?: string;
+    level?: string;
+    since?: string;
+}
+/**
+ * Tidewave log store.
+ *
+ * Storing logs in memory can be problematic, because some frameworks
+ * can use multiple execution contexts with isolated module loading
+ * and globals. In such circumstances, if we import the logger and
+ * write to it within the app, it may be a different logger instance
+ * from the one that the MCP server uses the get the logs. To avoid
+ * issues we persist logs in a NDJSON file, so it works across
+ * execution contexts.
+ */
+export declare class TidewaveLogger {
+    private logFilePath;
+    constructor();
+    /**
+     * Store a log entry.
+     */
+    addLog(log: StoredLogRecord): Promise<void>;
+    /**
+     * Get stored logs.
+     */
+    getLogs(options?: LogFilterOptions): Promise<StoredLogRecord[]>;
+    private getAllLogs;
+}
+export declare const tidewaveLogger: TidewaveLogger;

package/dist/logger/tidewave-span-processor.d.ts

@@ -3,7 +3,7 @@ import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';
 import type { Span, Context } from '@opentelemetry/api';
 /**
  * Custom SpanProcessor that converts OpenTelemetry spans to logs and writes them
- * directly to the circular buffer.
+ * directly to the tidewave logger.
  * This is used to capture Next.js HTTP request/response spans and
  * make them available via the get_logs tool.
  */
@@ -14,7 +14,7 @@ export declare class TidewaveSpanProcessor implements SpanProcessor {
     onStart(_span: Span, _parentContext: Context): void;
     /**
      * Called when a span ends. This is where we convert the span to a log entry
-     * and write it directly to the circular buffer.
+     * and write it directly to the tidewave logger.
      */
     onEnd(span: ReadableSpan): void;
     /**

package/dist/next-js/handler.d.ts

@@ -7,5 +7,6 @@ export type FunctionLike = (...args: any[]) => unknown;
 export type Nextable<H extends FunctionLike> = (...args: [...Parameters<H>, NextHandler]) => ValueOrPromise<any>;
 export type ValueOrPromise<T> = T | Promise<T>;
 export type RequestHandler<Req extends Request, Res extends Response> = (req: Req, res: Res) => ValueOrPromise<void>;
+export declare function getRequestLocalPort(request: Request): number | undefined;
 export declare function tidewaveHandler(config?: TidewaveConfig): Promise<NextJsHandler>;
 export {};