tidewave 0.1.0 → 0.3.0

package/dist/core.d.ts

@@ -0,0 +1,77 @@
+import ts from 'typescript';
+export type Program = ts.Program;
+export type TypeChecker = ts.TypeChecker;
+export type SourceFile = ts.SourceFile;
+export type Runtime = 'node' | 'bun' | 'deno';
+export interface ModuleRequest {
+    readonly specifier: string;
+    readonly source: string;
+    readonly runtime?: Runtime;
+}
+export interface ResolvedModule {
+    readonly path: string;
+    readonly format: 'commonjs' | 'module' | 'typescript';
+    readonly content?: string;
+}
+export interface InternalResolvedModule {
+    readonly sourceFile: ts.SourceFile;
+    readonly program: ts.Program;
+}
+export interface ExtractionRequest {
+    readonly module: string;
+    readonly symbol: string;
+    readonly member?: string;
+    readonly isStatic?: boolean;
+}
+export interface SymbolInfo {
+    readonly name: string;
+    readonly kind: string;
+    readonly type: string;
+    readonly documentation?: string;
+    readonly signature?: string;
+    readonly location: string;
+    readonly jsDoc?: string;
+}
+export interface ExtractorOptions {
+    readonly prefix?: string;
+}
+export interface ResolveError {
+    readonly success: false;
+    readonly error: {
+        readonly code: 'MODULE_NOT_FOUND' | 'INVALID_SPECIFIER' | 'RESOLUTION_FAILED';
+        readonly message: string;
+        readonly details?: unknown;
+    };
+}
+export interface ExtractError {
+    readonly error: {
+        readonly code: 'SYMBOL_NOT_FOUND' | 'PARSE_ERROR' | 'INVALID_REQUEST' | 'MODULE_NOT_FOUND' | 'MEMBER_NOT_FOUND' | 'TYPE_ERROR';
+        readonly message: string;
+        readonly details?: unknown;
+    };
+}
+export interface EvaluationRequest {
+    code: string;
+    args: unknown[];
+    timeout: number;
+}
+export interface EvaluatedModuleResult {
+    success: boolean;
+    result: string | null;
+    stdout: string;
+    stderr: string;
+}
+export type ResolveResult = ResolvedModule | ResolveError;
+export type ExtractResult = SymbolInfo | 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 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/core.js

@@ -0,0 +1,64 @@
+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/core.ts
+function isError(result) {
+  return result != null && "success" in result && result.success === false;
+}
+function isResolveError(result) {
+  return result != null && "success" in result && result.success === false;
+}
+function isExtractError(result) {
+  return result != null && "error" in result;
+}
+function resolveError(specifier, source) {
+  return {
+    success: false,
+    error: {
+      code: "MODULE_NOT_FOUND",
+      message: `Cannot resolve module '${specifier}' from '${source}'`
+    }
+  };
+}
+function createExtractError(code, message, details) {
+  return {
+    error: {
+      code,
+      message,
+      details
+    }
+  };
+}
+export {
+  resolveError,
+  isResolveError,
+  isExtractError,
+  isError,
+  createExtractError
+};

package/dist/evaluation/code_executor.d.ts

@@ -0,0 +1,2 @@
+import type { EvaluatedModuleResult, EvaluationRequest } from '../core';
+export declare function executeIsolated(request: EvaluationRequest): Promise<EvaluatedModuleResult>;

package/dist/evaluation/code_executor.js

@@ -0,0 +1,104 @@
+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) {
+    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";
+async function executeIsolated(request) {
+  return new Promise((resolve) => {
+    const workerPath = __require.resolve("./eval_worker");
+    const child = fork(workerPath, { silent: true });
+    const evaluation = {
+      success: false,
+      result: null,
+      stdout: "",
+      stderr: ""
+    };
+    child.stdout?.on("data", (data) => {
+      evaluation.stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      evaluation.stderr += data.toString();
+    });
+    child.on("message", (msg) => {
+      if (msg.type === "result") {
+        const { data, success } = msg;
+        evaluation.result = data;
+        evaluation.success = success;
+      }
+    });
+    child.on("exit", (code) => {
+      resolve({
+        success: evaluation.success && code === 0,
+        result: evaluation.result,
+        stdout: evaluation.stdout.trim(),
+        stderr: evaluation.stderr.trim()
+      });
+    });
+    const { timeout } = request;
+    const timeoutId = setTimeout(() => {
+      child.kill("SIGKILL");
+      resolve({
+        success: false,
+        result: `Evaluation timed out after ${timeout} milliseconds`,
+        stdout: evaluation.stdout,
+        stderr: evaluation.stderr
+      });
+    }, timeout);
+    child.on("exit", () => clearTimeout(timeoutId));
+    child.send(request);
+  });
+}
+export {
+  executeIsolated
+};

package/dist/evaluation/eval_worker.d.ts

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

package/dist/evaluation/eval_worker.js

@@ -0,0 +1,53 @@
+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) {
+    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);
+});

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

@@ -0,0 +1,2 @@
+import { type Request, type Response, type NextFn } from '..';
+export declare function handleMcp(req: Request, res: Response, next: NextFn): Promise<void>;

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

@@ -0,0 +1,6 @@
+import { type Request, type Response, type NextFn } from '../index';
+export declare function handleShell(req: Request, res: Response, next: NextFn): Promise<void>;
+export declare function getShellCommand(command: string): {
+    cmd: string;
+    args: string[];
+};

package/dist/http/index.d.ts

@@ -0,0 +1,15 @@
+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 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;
+export declare function methodNotAllowed(res: Response): void;