@vibetools/dokploy-mcp 1.0.0 → 2.0.0

package/dist/codemode/context/search-context.js

@@ -0,0 +1,42 @@
+import { dokployCatalog, getCatalogEndpoint, getCatalogEndpointsByTag, } from '../../generated/dokploy-catalog.js';
+import { procedureSchemas } from '../../generated/dokploy-schemas.js';
+export function createSearchCatalogView() {
+    return {
+        endpoints: dokployCatalog.endpoints,
+        byTag: dokployCatalog.byTag,
+        byProcedure: dokployCatalog.byProcedure,
+        byPath: dokployCatalog.byPath,
+        get: (id) => {
+            const endpoint = getCatalogEndpoint(id);
+            if (!endpoint)
+                return null;
+            const procedure = endpoint.procedure;
+            const schema = procedureSchemas[procedure];
+            return {
+                ...endpoint,
+                inputSchema: schema?.inputSchema ?? null,
+                outputSchema: schema?.outputSchema ?? null,
+            };
+        },
+        getByTag: (tag) => getCatalogEndpointsByTag(tag),
+        searchText: (query) => {
+            const normalized = query.trim().toLowerCase();
+            if (normalized.length === 0)
+                return [];
+            return dokployCatalog.endpoints.filter((endpoint) => {
+                const haystack = [
+                    endpoint.procedure,
+                    endpoint.path,
+                    endpoint.tag,
+                    endpoint.summary ?? '',
+                    endpoint.description ?? '',
+                    ...endpoint.requiredInputs,
+                    ...endpoint.optionalInputs,
+                ]
+                    .join(' ')
+                    .toLowerCase();
+                return haystack.includes(normalized);
+            });
+        },
+    };
+}

package/dist/codemode/gateway/api-gateway.d.ts

@@ -0,0 +1,12 @@
+import { api } from '../../api/client.js';
+import { procedureSchemas } from '../../generated/dokploy-schemas.js';
+import { type GatewayTraceEntry } from './trace.js';
+type ProcedureName = keyof typeof procedureSchemas;
+type RequestApi = typeof api;
+export interface GatewayCallResult {
+    data: unknown;
+    trace: GatewayTraceEntry;
+}
+export declare function invokeProcedureWithApi(procedure: ProcedureName | string, input?: Record<string, unknown>, requestApi?: RequestApi): Promise<GatewayCallResult>;
+export declare function invokeProcedure(procedure: ProcedureName | string, input?: Record<string, unknown>): Promise<GatewayCallResult>;
+export {};

package/dist/codemode/gateway/api-gateway.js

@@ -0,0 +1,160 @@
+import { ApiError, api } from '../../api/client.js';
+import { procedureSchemas } from '../../generated/dokploy-schemas.js';
+import { formatGatewayError } from './error-format.js';
+import { finishTrace, startTrace } from './trace.js';
+const RETRYABLE_STATUS_CODES = new Set([429, 502, 503, 504]);
+function resolveGatewayRetryCount() {
+    const parsed = Number.parseInt(process.env.DOKPLOY_MCP_GATEWAY_RETRIES ?? '2', 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 2;
+}
+function shouldRetryGatewayError(error, method, attempt, maxRetries) {
+    if (!(error instanceof ApiError)) {
+        return false;
+    }
+    if (method !== 'GET') {
+        return false;
+    }
+    if (attempt >= maxRetries) {
+        return false;
+    }
+    return RETRYABLE_STATUS_CODES.has(error.status);
+}
+async function delay(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function validateAgainstSchema(value, schema, path = '') {
+    if (!schema || typeof schema !== 'object') {
+        return [];
+    }
+    const schemaObject = schema;
+    if (schemaObject.anyOf && Array.isArray(schemaObject.anyOf)) {
+        const variants = schemaObject.anyOf;
+        const variantErrors = variants.map((variant) => validateAgainstSchema(value, variant, path));
+        if (variantErrors.some((errors) => errors.length === 0)) {
+            return [];
+        }
+        return variantErrors[0] ?? [];
+    }
+    if (schemaObject.enum && Array.isArray(schemaObject.enum)) {
+        if (!schemaObject.enum.includes(value)) {
+            return [`${path || 'value'} must be one of ${schemaObject.enum.join(', ')}`];
+        }
+        return [];
+    }
+    return validateTypedSchema(value, schemaObject, path);
+}
+function validateTypedSchema(value, schemaObject, path) {
+    switch (schemaObject.type) {
+        case 'object':
+            return validateObjectSchema(value, schemaObject, path);
+        case 'array':
+            return validateArraySchema(value, schemaObject, path);
+        case 'string':
+            return validatePrimitive(value, 'string', path);
+        case 'number':
+        case 'integer':
+            return validatePrimitive(value, 'number', path);
+        case 'boolean':
+            return validatePrimitive(value, 'boolean', path);
+        case 'null':
+            return value === null ? [] : [`${path || 'value'} must be null`];
+        default:
+            return [];
+    }
+}
+function validateObjectSchema(value, schemaObject, path) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return [`${path || 'value'} must be an object`];
+    }
+    const objectValue = value;
+    const properties = schemaObject.properties ?? {};
+    const required = schemaObject.required ?? [];
+    const errors = [];
+    for (const key of required) {
+        if (!(key in objectValue) || objectValue[key] == null) {
+            errors.push(`${path ? `${path}.` : ''}${key} is required`);
+        }
+    }
+    for (const [key, propertySchema] of Object.entries(properties)) {
+        if (key in objectValue) {
+            errors.push(...validateAgainstSchema(objectValue[key], propertySchema, path ? `${path}.${key}` : key));
+        }
+    }
+    return errors;
+}
+function validateArraySchema(value, schemaObject, path) {
+    if (!Array.isArray(value)) {
+        return [`${path || 'value'} must be an array`];
+    }
+    const itemSchema = schemaObject.items;
+    const errors = [];
+    for (const [index, entry] of value.entries()) {
+        errors.push(...validateAgainstSchema(entry, itemSchema, `${path || 'value'}[${index}]`));
+    }
+    return errors;
+}
+function validatePrimitive(value, type, path) {
+    return typeof value === type ? [] : [`${path || 'value'} must be a ${type}`];
+}
+export async function invokeProcedureWithApi(procedure, input = {}, requestApi = api) {
+    const schema = procedureSchemas[procedure];
+    if (!schema) {
+        throw formatGatewayError({
+            type: 'validation_error',
+            procedure,
+            message: `Unknown Dokploy procedure: ${procedure}`,
+        });
+    }
+    const validationErrors = validateAgainstSchema(input, schema.inputSchema);
+    if (validationErrors.length > 0) {
+        throw formatGatewayError({
+            type: 'validation_error',
+            procedure,
+            message: validationErrors.join('; '),
+        });
+    }
+    const trace = startTrace(procedure, schema.method);
+    const maxRetries = resolveGatewayRetryCount();
+    try {
+        let attempt = 0;
+        while (true) {
+            try {
+                const data = schema.method === 'GET'
+                    ? await requestApi.get(schema.path, input)
+                    : await requestApi.post(schema.path, input);
+                return {
+                    data,
+                    trace: finishTrace(trace),
+                };
+            }
+            catch (error) {
+                if (!shouldRetryGatewayError(error, schema.method, attempt, maxRetries)) {
+                    throw error;
+                }
+                attempt += 1;
+                await delay(50 * attempt);
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof ApiError) {
+            throw formatGatewayError({
+                type: 'dokploy_error',
+                procedure,
+                status: error.status,
+                message: error.message,
+            });
+        }
+        if (error && typeof error === 'object' && 'type' in error && 'message' in error) {
+            throw error;
+        }
+        throw formatGatewayError({
+            type: 'sandbox_error',
+            procedure,
+            message: error instanceof Error ? error.message : 'Unknown gateway error',
+        });
+    }
+}
+export async function invokeProcedure(procedure, input = {}) {
+    return invokeProcedureWithApi(procedure, input, api);
+}

package/dist/codemode/gateway/error-format.d.ts

@@ -0,0 +1,13 @@
+export interface GatewayErrorPayload {
+    ok: false;
+    type: 'dokploy_error' | 'validation_error' | 'sandbox_error';
+    status?: number;
+    procedure?: string;
+    message: string;
+}
+export declare function formatGatewayError(input: {
+    type: GatewayErrorPayload['type'];
+    message: string;
+    status?: number;
+    procedure?: string;
+}): GatewayErrorPayload;

package/dist/codemode/gateway/error-format.js

@@ -0,0 +1,9 @@
+export function formatGatewayError(input) {
+    return {
+        ok: false,
+        type: input.type,
+        status: input.status,
+        procedure: input.procedure,
+        message: input.message,
+    };
+}

package/dist/codemode/gateway/request-normalizer.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeTrpcParams(body: unknown): Record<string, unknown>;
+export declare function buildTrpcQueryString(body: unknown): string;
+export declare function buildTrpcPostBody(body: unknown): string | undefined;

package/dist/codemode/gateway/request-normalizer.js

@@ -0,0 +1,21 @@
+export function normalizeTrpcParams(body) {
+    if (!body || typeof body !== 'object') {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(body).filter(([, value]) => value != null));
+}
+export function buildTrpcQueryString(body) {
+    if (body == null) {
+        return '';
+    }
+    const params = normalizeTrpcParams(body);
+    return new URLSearchParams({
+        input: JSON.stringify({ json: params }),
+    }).toString();
+}
+export function buildTrpcPostBody(body) {
+    if (body == null) {
+        return undefined;
+    }
+    return JSON.stringify({ json: body });
+}

package/dist/codemode/gateway/trace.d.ts

@@ -0,0 +1,13 @@
+export interface GatewayTraceEntry {
+    procedure: string;
+    method: 'GET' | 'POST';
+    startedAt: number;
+    finishedAt: number;
+    durationMs: number;
+}
+export declare function startTrace(procedure: string, method: 'GET' | 'POST'): {
+    procedure: string;
+    method: "GET" | "POST";
+    startedAt: number;
+};
+export declare function finishTrace(trace: ReturnType<typeof startTrace>): GatewayTraceEntry;

package/dist/codemode/gateway/trace.js

@@ -0,0 +1,11 @@
+export function startTrace(procedure, method) {
+    return { procedure, method, startedAt: Date.now() };
+}
+export function finishTrace(trace) {
+    const finishedAt = Date.now();
+    return {
+        ...trace,
+        finishedAt,
+        durationMs: finishedAt - trace.startedAt,
+    };
+}

package/dist/codemode/sandbox/host.d.ts

@@ -0,0 +1,11 @@
+import type { GatewayCallResult } from '../gateway/api-gateway.js';
+interface SandboxHostOptions {
+    maxCalls?: number;
+    executor?: (procedure: string, input?: Record<string, unknown>) => Promise<GatewayCallResult>;
+}
+export interface SandboxHost {
+    call(procedure: string, input?: Record<string, unknown>): Promise<GatewayCallResult>;
+    getCalls(): GatewayCallResult['trace'][];
+}
+export declare function createSandboxHost(options?: SandboxHostOptions): SandboxHost;
+export {};

package/dist/codemode/sandbox/host.js

@@ -0,0 +1,28 @@
+import { invokeProcedure } from '../gateway/api-gateway.js';
+import { resolveSandboxLimits } from './limits.js';
+export function createSandboxHost(options = {}) {
+    const limits = resolveSandboxLimits();
+    const maxCalls = options.maxCalls ?? limits.maxCalls;
+    const executor = options.executor ?? invokeProcedure;
+    const traces = [];
+    let callCount = 0;
+    let responseBytes = 0;
+    return {
+        async call(procedure, input = {}) {
+            callCount += 1;
+            if (callCount > maxCalls) {
+                throw new Error(`Code Mode execute exceeded ${maxCalls} API calls.`);
+            }
+            const result = await executor(procedure, input);
+            responseBytes += Buffer.byteLength(JSON.stringify(result.data), 'utf8');
+            if (responseBytes > limits.maxResponseBytes) {
+                throw new Error(`Code Mode execute exceeded ${limits.maxResponseBytes} bytes of Dokploy responses.`);
+            }
+            traces.push(result.trace);
+            return result;
+        },
+        getCalls() {
+            return traces;
+        },
+    };
+}

package/dist/codemode/sandbox/limits.d.ts

@@ -0,0 +1,2 @@
+import type { SandboxLimits } from './types.js';
+export declare function resolveSandboxLimits(): SandboxLimits;

package/dist/codemode/sandbox/limits.js

@@ -0,0 +1,20 @@
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_MAX_RESULT_BYTES = 128 * 1024;
+const DEFAULT_MAX_LOG_BYTES = 8 * 1024;
+const DEFAULT_MAX_CALLS = 25;
+const DEFAULT_MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
+const DEFAULT_MAX_HEAP_DELTA_BYTES = 16 * 1024 * 1024;
+function parsePositiveInt(value, fallback) {
+    const parsed = Number.parseInt(value ?? '', 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+export function resolveSandboxLimits() {
+    return {
+        timeoutMs: parsePositiveInt(process.env.DOKPLOY_MCP_SANDBOX_TIMEOUT_MS, DEFAULT_TIMEOUT_MS),
+        maxResultBytes: parsePositiveInt(process.env.DOKPLOY_MCP_SANDBOX_MAX_RESULT_BYTES, DEFAULT_MAX_RESULT_BYTES),
+        maxLogBytes: parsePositiveInt(process.env.DOKPLOY_MCP_SANDBOX_MAX_LOG_BYTES, DEFAULT_MAX_LOG_BYTES),
+        maxCalls: parsePositiveInt(process.env.DOKPLOY_MCP_SANDBOX_MAX_CALLS, DEFAULT_MAX_CALLS),
+        maxResponseBytes: parsePositiveInt(process.env.DOKPLOY_MCP_SANDBOX_MAX_RESPONSE_BYTES, DEFAULT_MAX_RESPONSE_BYTES),
+        maxHeapDeltaBytes: parsePositiveInt(process.env.DOKPLOY_MCP_SANDBOX_MAX_HEAP_DELTA_BYTES, DEFAULT_MAX_HEAP_DELTA_BYTES),
+    };
+}

package/dist/codemode/sandbox/runner.d.ts

@@ -0,0 +1,8 @@
+import type { SandboxExecutionResult, SandboxLimits } from './types.js';
+interface RunSandboxedFunctionOptions<TContext extends Record<string, unknown>> {
+    code: string;
+    context: TContext;
+    limits?: SandboxLimits;
+}
+export declare function runSandboxedFunction<TContext extends Record<string, unknown>>({ code, context, limits: providedLimits, }: RunSandboxedFunctionOptions<TContext>): Promise<SandboxExecutionResult>;
+export {};

package/dist/codemode/sandbox/runner.js

@@ -0,0 +1,113 @@
+import { createContext, Script } from 'node:vm';
+import { resolveSandboxLimits } from './limits.js';
+import { serializeSandboxValue } from './serialize.js';
+function deepFreeze(value) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            deepFreeze(item);
+        }
+        return Object.freeze(value);
+    }
+    if (value && typeof value === 'object') {
+        for (const item of Object.values(value)) {
+            deepFreeze(item);
+        }
+        return Object.freeze(value);
+    }
+    return value;
+}
+export async function runSandboxedFunction({ code, context, limits: providedLimits, }) {
+    const limits = providedLimits ?? resolveSandboxLimits();
+    const logs = [];
+    let loggedBytes = 0;
+    const frozenContext = deepFreeze(context);
+    const sandbox = createContext({
+        __context: frozenContext,
+        console: {
+            log: (...args) => {
+                const line = args
+                    .map((arg) => {
+                    try {
+                        return typeof arg === 'string' ? arg : JSON.stringify(arg);
+                    }
+                    catch {
+                        return String(arg);
+                    }
+                })
+                    .join(' ');
+                loggedBytes += Buffer.byteLength(line, 'utf8');
+                if (loggedBytes > limits.maxLogBytes) {
+                    throw new Error(`Sandbox logs exceeded ${limits.maxLogBytes} bytes.`);
+                }
+                logs.push(line);
+            },
+        },
+        process: undefined,
+        fetch: undefined,
+        require: undefined,
+        module: undefined,
+        exports: undefined,
+        setTimeout: undefined,
+        setInterval: undefined,
+        clearTimeout: undefined,
+        clearInterval: undefined,
+        queueMicrotask: undefined,
+        Buffer: undefined,
+        Function: undefined,
+        eval: undefined,
+        WebAssembly: undefined,
+        SharedArrayBuffer: undefined,
+    }, {
+        codeGeneration: {
+            strings: false,
+            wasm: false,
+        },
+    });
+    const script = new Script(`
+      (async () => {
+        const __fn = (${code})
+        if (typeof __fn !== 'function') {
+          throw new Error('Sandbox code must evaluate to a function.')
+        }
+        if (__fn.constructor?.name !== 'AsyncFunction') {
+          throw new Error('Sandbox code must evaluate to an async function.')
+        }
+        return await __fn(__context)
+      })()
+    `, {
+        filename: 'codemode-sandbox.js',
+    });
+    let timeoutId;
+    let settled = false;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            reject(new Error(`Sandbox execution timed out after ${limits.timeoutMs}ms.`));
+        }, limits.timeoutMs);
+        timeoutId.unref?.();
+    });
+    void timeoutPromise.catch(() => {
+        // Intentionally swallowed because Promise.race may resolve through the VM timeout path first.
+    });
+    const executionPromise = Promise.resolve(script.runInContext(sandbox, {
+        timeout: limits.timeoutMs,
+    }));
+    const result = await Promise.race([executionPromise, timeoutPromise]).finally(() => {
+        settled = true;
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    });
+    const serializedResult = serializeSandboxValue(result, limits.maxResultBytes);
+    const heapEstimateBytes = Buffer.byteLength(JSON.stringify(serializedResult), 'utf8');
+    if (heapEstimateBytes > limits.maxHeapDeltaBytes) {
+        throw new Error(`Sandbox heap delta exceeded ${limits.maxHeapDeltaBytes} bytes.`);
+    }
+    return {
+        result: serializedResult,
+        logs,
+    };
+}

package/dist/codemode/sandbox/runtime.d.ts

@@ -0,0 +1,2 @@
+export type SandboxRuntime = 'local' | 'subprocess';
+export declare function resolveSandboxRuntime(value?: string | undefined): SandboxRuntime;

package/dist/codemode/sandbox/runtime.js

@@ -0,0 +1,3 @@
+export function resolveSandboxRuntime(value = process.env.DOKPLOY_MCP_SANDBOX_RUNTIME) {
+    return value === 'local' ? 'local' : 'subprocess';
+}

package/dist/codemode/sandbox/serialize.d.ts

@@ -0,0 +1 @@
+export declare function serializeSandboxValue(value: unknown, maxBytes: number): unknown;

package/dist/codemode/sandbox/serialize.js

@@ -0,0 +1,45 @@
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    if (Object.prototype.toString.call(value) !== '[object Object]') {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return (prototype === Object.prototype ||
+        prototype === null ||
+        prototype?.constructor?.name === 'Object');
+}
+export function serializeSandboxValue(value, maxBytes) {
+    const normalized = normalizeValue(value);
+    const json = JSON.stringify(normalized);
+    if (json === undefined) {
+        throw new Error('Sandbox returned a non-serializable value.');
+    }
+    const bytes = Buffer.byteLength(json, 'utf8');
+    if (bytes > maxBytes) {
+        throw new Error(`Sandbox result exceeded ${maxBytes} bytes.`);
+    }
+    return JSON.parse(json);
+}
+function normalizeValue(value) {
+    if (typeof value === 'function' || typeof value === 'symbol' || typeof value === 'bigint') {
+        throw new Error('Sandbox returned a non-serializable value.');
+    }
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    if (value === undefined) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => normalizeValue(entry));
+    }
+    if (isPlainObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, normalizeValue(entry)]));
+    }
+    return String(value);
+}

package/dist/codemode/sandbox/subprocess-runner.d.ts

@@ -0,0 +1,10 @@
+import type { SandboxExecutionResult, SandboxLimits } from './types.js';
+export declare function runSearchInSubprocess(options: {
+    code: string;
+    limits?: SandboxLimits;
+}): Promise<SandboxExecutionResult>;
+export declare function runExecuteInSubprocess(options: {
+    code: string;
+    limits?: SandboxLimits;
+    onCall: (procedure: string, input?: Record<string, unknown>) => Promise<unknown>;
+}): Promise<SandboxExecutionResult>;

package/dist/codemode/sandbox/subprocess-runner.js

@@ -0,0 +1,91 @@
+import { fork } from 'node:child_process';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolveSandboxLimits } from './limits.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const workerPath = resolve(__dirname, '../../../dist/codemode/sandbox/worker-entry.js');
+function createWorker() {
+    return fork(workerPath, {
+        stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
+        env: {},
+        execArgv: [],
+    });
+}
+function resolveLimits(limits) {
+    return limits ?? resolveSandboxLimits();
+}
+function handleWorkerExit(rejectPromise, code) {
+    if (code && code !== 0) {
+        rejectPromise(new Error(`Sandbox worker exited with code ${code}`));
+    }
+}
+function finishWorker(worker, payload, resolvePromise, rejectPromise) {
+    worker.disconnect();
+    worker.kill();
+    if (payload.ok) {
+        resolvePromise({
+            result: payload.result,
+            logs: payload.logs ?? [],
+        });
+    }
+    else {
+        rejectPromise(new Error(payload.error ?? 'Unknown sandbox subprocess error'));
+    }
+}
+export async function runSearchInSubprocess(options) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        const worker = createWorker();
+        worker.on('message', (message) => {
+            const payload = message;
+            if (payload.type !== 'done') {
+                return;
+            }
+            finishWorker(worker, payload, resolvePromise, rejectPromise);
+        });
+        worker.on('error', rejectPromise);
+        worker.on('exit', (code) => handleWorkerExit(rejectPromise, code));
+        worker.send({
+            type: 'run',
+            mode: 'search',
+            code: options.code,
+            limits: resolveLimits(options.limits),
+        });
+    });
+}
+export async function runExecuteInSubprocess(options) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        const worker = createWorker();
+        worker.on('message', async (message) => {
+            const payload = message;
+            if (payload.type === 'call') {
+                const requestId = payload.requestId;
+                try {
+                    const data = await options.onCall(String(payload.procedure), payload.input ?? {});
+                    worker.send({ type: 'callResult', requestId, ok: true, data });
+                }
+                catch (error) {
+                    worker.send({
+                        type: 'callResult',
+                        requestId,
+                        ok: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+                return;
+            }
+            const done = payload;
+            if (done.type !== 'done') {
+                return;
+            }
+            finishWorker(worker, done, resolvePromise, rejectPromise);
+        });
+        worker.on('error', rejectPromise);
+        worker.on('exit', (code) => handleWorkerExit(rejectPromise, code));
+        worker.send({
+            type: 'run',
+            mode: 'execute',
+            code: options.code,
+            limits: resolveLimits(options.limits),
+        });
+    });
+}

package/dist/codemode/sandbox/types.d.ts

@@ -0,0 +1,12 @@
+export interface SandboxLimits {
+    timeoutMs: number;
+    maxResultBytes: number;
+    maxLogBytes: number;
+    maxCalls: number;
+    maxResponseBytes: number;
+    maxHeapDeltaBytes: number;
+}
+export interface SandboxExecutionResult {
+    result: unknown;
+    logs: string[];
+}

package/dist/codemode/sandbox/types.js

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

package/dist/codemode/sandbox/worker-entry.d.ts

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