tidewave 0.2.4 → 0.3.0

package/README.md

@@ -56,6 +56,70 @@ tidewave({
 });
 ```
 
+### HTTP MCP via Next.js Integration
+
+Tidewave provides seamless integration with Next.js through a handler function.
+Add the handler to your API routes **and** `middleware.ts`:
+
+> [!WARNING] Note that the below helper functions will only work on development
+> mode `NODE_ENV === 'development'` if the validation fails, an Error will be
+> thrown
+
+**Pages Router** - Create `pages/api/tidewave/[...all].ts`:
+
+```typescript
+import { tidewaveHandler } from 'tidewave/next-js';
+
+export default await tidewaveHandler();
+
+// Next.js specific config
+export const config = {
+  runtime: 'nodejs',
+  api: {
+    bodyParser: false, // tidewave already parses the body internally
+  },
+};
+```
+
+This exposes MCP endpoints at `/api/tidewave/mcp` and `/api/tidewave/shell`.
+
+Then create `middleware.ts` with:
+
+```typescript
+import { tidewaveMiddleware } from 'tidewave/next-js';
+
+export const middleware = tidewaveMiddleware();
+
+export const config = {
+  matcher: '/tidewave/(.*)',
+};
+```
+
+In case you already have an existing `middleware.ts`:
+
+```typescript
+import { tidewaveMiddleware } from 'tidewave/next-js';
+
+const withTidewave = tidewaveMiddleware();
+
+export function middleware(req: NextRequest): Promise<NextResponse> {
+  // This will return a unchanged NextResponse.next()
+  // if path doesn't match with `/tidewave`
+  // if does match it will rewrite to `/api/tidewave` instead
+  withTidewave(req, (req: NextRequest) => {
+    // your own logic
+    return NextResponse.json({ message: 'hello, world!' });
+  });
+}
+
+export const config = {
+  matcher: [
+    '/tidewave/(.*)', // tidewave specific matcher
+    '/your/route/', // your specific matcher
+  ],
+};
+```
+
 ### CLI Usage
 
 Tidewave also provides the MCP features over a CLI tool. Use it directly via

package/dist/cli/index.js

@@ -11055,13 +11055,36 @@ async function extractSymbol(request, options = {}) {
     };
   }
 }
+// src/evaluation/eval_worker.ts
+process.on("message", async ({ code, args }) => {
+  if (!process.send) {
+    console.error("[Tidewave] Unable to establish communication channel with code-executor.");
+    process.exit(1);
+  }
+  try {
+    const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
+    const fn = new AsyncFunction(code);
+    const result = await fn(...args);
+    process.send({
+      type: "result",
+      success: true,
+      data: (result || null) && result
+    });
+  } catch (error) {
+    process.send({
+      type: "result",
+      success: false,
+      data: new String(error)
+    });
+  }
+  process.exit(0);
+});
+
 // src/evaluation/code_executor.ts
 import { fork } from "child_process";
-import { join } from "path";
-var __dirname = "/Users/zoedsoupe/dev/dashbit/tidewave_javascript/src/evaluation";
 async function executeIsolated(request) {
   return new Promise((resolve) => {
-    const workerPath = join(__dirname, "eval_worker.ts");
+    const workerPath = __require.resolve("./eval_worker");
     const child = fork(workerPath, { silent: true });
     const evaluation = {
       success: false,
@@ -14033,7 +14056,7 @@ var EMPTY_COMPLETION_RESULT = {
 
 // package.json
 var name = "tidewave";
-var version = "0.2.3";
+var version = "0.3.0";
 
 // src/mcp.ts
 var {

package/dist/core.d.ts

@@ -69,3 +69,9 @@ export declare function isResolveError(result: ResolveResult | InternalResolveRe
 export declare function isExtractError(result: ExtractResult): result is ExtractError;
 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;
+    allowRemoteAccess?: boolean;
+    allowedOrigins?: string[];
+}

package/dist/evaluation/code_executor.js

@@ -27,13 +27,36 @@ var __export = (target, all) => {
 };
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/evaluation/eval_worker.ts
+process.on("message", async ({ code, args }) => {
+  if (!process.send) {
+    console.error("[Tidewave] Unable to establish communication channel with code-executor.");
+    process.exit(1);
+  }
+  try {
+    const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
+    const fn = new AsyncFunction(code);
+    const result = await fn(...args);
+    process.send({
+      type: "result",
+      success: true,
+      data: (result || null) && result
+    });
+  } catch (error) {
+    process.send({
+      type: "result",
+      success: false,
+      data: new String(error)
+    });
+  }
+  process.exit(0);
+});
+
 // src/evaluation/code_executor.ts
 import { fork } from "child_process";
-import { join } from "path";
-var __dirname = "/Users/zoedsoupe/dev/dashbit/tidewave_javascript/src/evaluation";
 async function executeIsolated(request) {
   return new Promise((resolve) => {
-    const workerPath = join(__dirname, "eval_worker.ts");
+    const workerPath = __require.resolve("./eval_worker");
     const child = fork(workerPath, { silent: true });
     const evaluation = {
       success: false,

package/dist/evaluation/eval_worker.js

@@ -1,3 +1,32 @@
+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 __require = /* @__PURE__ */ createRequire(import.meta.url);
+
 // src/evaluation/eval_worker.ts
 process.on("message", async ({ code, args }) => {
   if (!process.send) {

package/dist/http/index.d.ts

@@ -1,17 +1,14 @@
 import type { ServerResponse } from 'http';
 import type { IncomingMessage, NextFunction, Server } from 'connect';
+import type { TidewaveConfig } from '../core';
 export interface Request extends IncomingMessage {
     body?: Record<string, unknown>;
 }
 export type Response = ServerResponse<IncomingMessage>;
 export type NextFn = NextFunction;
 export declare const ENDPOINT: "/tidewave";
-export interface TidewaveConfig {
-    allowRemoteAccess?: boolean;
-    allowedOrigins?: string[];
-    port?: number;
-    host?: string;
-}
+export type Handler = (req: Request, res: Response, next: NextFn) => Promise<void>;
+export declare const HANDLERS: Record<string, Handler>;
 export declare function configureServer(server?: Server, config?: TidewaveConfig): Server;
 export declare function serve(server: Server, config?: TidewaveConfig): void;
 export declare function checkSecurity(config: TidewaveConfig): (req: Request, res: Response, next: NextFn) => void;

package/dist/http/index.js

@@ -6194,7 +6194,7 @@ var require_ajv = __commonJS((exports, module) => {
   function noop() {}
 });
 
-// node_modules/connect/node_modules/debug/node_modules/ms/index.js
+// node_modules/connect/node_modules/ms/index.js
 var require_ms = __commonJS((exports, module) => {
   var s = 1000;
   var m = s * 60;
@@ -30078,13 +30078,36 @@ async function extractSymbol(request, options = {}) {
     };
   }
 }
+// src/evaluation/eval_worker.ts
+process.on("message", async ({ code, args }) => {
+  if (!process.send) {
+    console.error("[Tidewave] Unable to establish communication channel with code-executor.");
+    process.exit(1);
+  }
+  try {
+    const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
+    const fn = new AsyncFunction(code);
+    const result = await fn(...args);
+    process.send({
+      type: "result",
+      success: true,
+      data: (result || null) && result
+    });
+  } catch (error) {
+    process.send({
+      type: "result",
+      success: false,
+      data: new String(error)
+    });
+  }
+  process.exit(0);
+});
+
 // src/evaluation/code_executor.ts
 import { fork } from "child_process";
-import { join } from "path";
-var __dirname = "/Users/zoedsoupe/dev/dashbit/tidewave_javascript/src/evaluation";
 async function executeIsolated(request) {
   return new Promise((resolve) => {
-    const workerPath = join(__dirname, "eval_worker.ts");
+    const workerPath = __require.resolve("./eval_worker");
     const child = fork(workerPath, { silent: true });
     const evaluation = {
       success: false,
@@ -33056,7 +33079,7 @@ var EMPTY_COMPLETION_RESULT = {
 
 // package.json
 var name = "tidewave";
-var version = "0.2.3";
+var version = "0.3.0";
 
 // src/mcp.ts
 var {
@@ -33172,9 +33195,21 @@ async function serveMcp(transport) {
 }
 
 // src/http/security.ts
+function fetchRemoteIp(req) {
+  const remote = req.socket.remoteAddress;
+  if (remote)
+    return remote;
+  const ip = req.headers["x-real-ip"] && req.headers["x-forwarded-for"] || null;
+  if (Array.isArray(ip)) {
+    return ip.join();
+  }
+  return ip;
+}
 function checkRemoteIp(req, res, config) {
-  const { remoteAddress } = req.socket;
-  if (isLocalIp(remoteAddress))
+  const ip = fetchRemoteIp(req);
+  if (!ip)
+    return false;
+  if (isLocalIp(ip))
     return true;
   if (config.allowRemoteAccess)
     return true;
@@ -33730,7 +33765,6 @@ async function handleMcp(req, res, next) {
       methodNotAllowed(res);
       return;
     }
-    console.debug(`[Tidewave] Received ${req.method} message`);
     const transport = new StreamableHTTPServerTransport({
       sessionIdGenerator: undefined,
       enableJsonResponse: true
@@ -33888,12 +33922,17 @@ var DEFAULT_OPTIONS = {
   port: 5001,
   host: "localhost"
 };
+var HANDLERS = {
+  mcp: handleMcp,
+  shell: handleShell
+};
 function configureServer(server = import_connect.default(), config = DEFAULT_OPTIONS) {
   const securityChecker = checkSecurity(config);
   server.use(`${ENDPOINT}`, securityChecker);
   server.use(`${ENDPOINT}`, import_body_parser.default.json());
-  server.use(`${ENDPOINT}/mcp`, handleMcp);
-  server.use(`${ENDPOINT}/shell`, handleShell);
+  for (const [path4, handler] of Object.entries(HANDLERS)) {
+    server.use(ENDPOINT + "/" + path4, handler);
+  }
   return server;
 }
 function serve(server, config = DEFAULT_OPTIONS) {
@@ -33919,5 +33958,6 @@ export {
   methodNotAllowed,
   configureServer,
   checkSecurity,
+  HANDLERS,
   ENDPOINT
 };

package/dist/http/security.d.ts

@@ -1,4 +1,5 @@
-import type { Request, Response, TidewaveConfig } from './index';
+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;

package/dist/http/security.js

@@ -28,9 +28,21 @@ var __export = (target, all) => {
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/http/security.ts
+function fetchRemoteIp(req) {
+  const remote = req.socket.remoteAddress;
+  if (remote)
+    return remote;
+  const ip = req.headers["x-real-ip"] && req.headers["x-forwarded-for"] || null;
+  if (Array.isArray(ip)) {
+    return ip.join();
+  }
+  return ip;
+}
 function checkRemoteIp(req, res, config) {
-  const { remoteAddress } = req.socket;
-  if (isLocalIp(remoteAddress))
+  const ip = fetchRemoteIp(req);
+  if (!ip)
+    return false;
+  if (isLocalIp(ip))
     return true;
   if (config.allowRemoteAccess)
     return true;

package/dist/index.js

@@ -821,13 +821,36 @@ async function extractSymbol(request, options = {}) {
     };
   }
 }
+// src/evaluation/eval_worker.ts
+process.on("message", async ({ code, args }) => {
+  if (!process.send) {
+    console.error("[Tidewave] Unable to establish communication channel with code-executor.");
+    process.exit(1);
+  }
+  try {
+    const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
+    const fn = new AsyncFunction(code);
+    const result = await fn(...args);
+    process.send({
+      type: "result",
+      success: true,
+      data: (result || null) && result
+    });
+  } catch (error) {
+    process.send({
+      type: "result",
+      success: false,
+      data: new String(error)
+    });
+  }
+  process.exit(0);
+});
+
 // src/evaluation/code_executor.ts
 import { fork } from "child_process";
-import { join } from "path";
-var __dirname = "/Users/zoedsoupe/dev/dashbit/tidewave_javascript/src/evaluation";
 async function executeIsolated(request) {
   return new Promise((resolve) => {
-    const workerPath = join(__dirname, "eval_worker.ts");
+    const workerPath = __require.resolve("./eval_worker");
     const child = fork(workerPath, { silent: true });
     const evaluation = {
       success: false,

package/dist/mcp.js

@@ -11054,13 +11054,36 @@ async function extractSymbol(request, options = {}) {
     };
   }
 }
+// src/evaluation/eval_worker.ts
+process.on("message", async ({ code, args }) => {
+  if (!process.send) {
+    console.error("[Tidewave] Unable to establish communication channel with code-executor.");
+    process.exit(1);
+  }
+  try {
+    const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
+    const fn = new AsyncFunction(code);
+    const result = await fn(...args);
+    process.send({
+      type: "result",
+      success: true,
+      data: (result || null) && result
+    });
+  } catch (error) {
+    process.send({
+      type: "result",
+      success: false,
+      data: new String(error)
+    });
+  }
+  process.exit(0);
+});
+
 // src/evaluation/code_executor.ts
 import { fork } from "child_process";
-import { join } from "path";
-var __dirname = "/Users/zoedsoupe/dev/dashbit/tidewave_javascript/src/evaluation";
 async function executeIsolated(request) {
   return new Promise((resolve) => {
-    const workerPath = join(__dirname, "eval_worker.ts");
+    const workerPath = __require.resolve("./eval_worker");
     const child = fork(workerPath, { silent: true });
     const evaluation = {
       success: false,
@@ -14032,7 +14055,7 @@ var EMPTY_COMPLETION_RESULT = {
 
 // package.json
 var name = "tidewave";
-var version = "0.2.3";
+var version = "0.3.0";
 
 // src/mcp.ts
 var {

package/dist/next-js.d.ts

@@ -0,0 +1,15 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { NextResponse, type NextRequest } from 'next/server';
+import { type Request, type Response } from './http';
+import type { TidewaveConfig } from './core';
+type NextJsHandler = (_req: NextApiRequest, _res: NextApiResponse) => Promise<void>;
+type NextJsMiddleware = (_req: NextRequest) => Promise<NextResponse>;
+type NextHandler = () => ValueOrPromise<unknown>;
+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 tidewaveHandler(config?: TidewaveConfig): Promise<NextJsHandler>;
+export declare function tidewaveMiddleware(): NextJsMiddleware;
+export declare function isTidewaveRoute(pathname: string): boolean;
+export {};