@codemod.com/codemod-sandbox 0.1.0

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export type * from "./types.js";
+export { Capabilities } from "./capabilities.js";
+export { SandboxedModule } from "./module.js";
+export { typeDeclarations } from "./type-declarations.js";

package/dist/src/index.js

@@ -0,0 +1,3 @@
+export { Capabilities } from "./capabilities.js";
+export { SandboxedModule } from "./module.js";
+export { typeDeclarations } from "./type-declarations.js";

package/dist/src/module.d.ts

@@ -0,0 +1,13 @@
+import type { CapabilityRegistry, DescriberInputs, DescriberOutputs, InvokeInputs, InvokeOutputs, ModuleSpec, Sandbox } from "./types.js";
+export { SandboxedModule };
+declare class SandboxedModule {
+    readonly sandbox: Sandbox;
+    readonly capabilities: CapabilityRegistry;
+    readonly modules: ModuleSpec;
+    private readonly executionTracker;
+    constructor(sandbox: Sandbox, capabilities: CapabilityRegistry, modules: ModuleSpec);
+    private executeModule;
+    private logExecutionTime;
+    invoke(name: string, inputs: InvokeInputs): Promise<InvokeOutputs>;
+    describe(name: string, inputs: DescriberInputs): Promise<DescriberOutputs>;
+}

package/dist/src/module.js

@@ -0,0 +1,46 @@
+import { Capabilities } from "./capabilities.js";
+export { SandboxedModule };
+class SandboxedModule {
+    sandbox;
+    capabilities;
+    modules;
+    executionTracker = new Map();
+    constructor(sandbox, capabilities, modules) {
+        this.sandbox = sandbox;
+        this.capabilities = capabilities;
+        this.modules = modules;
+    }
+    async executeModule(operation, moduleName, moduleInputs) {
+        const sessionId = crypto.randomUUID();
+        const operationLabel = operation === "describe" ? "Describe" : "Invoke";
+        const executionLabel = `${operationLabel} module "${moduleName}": uuid="${sessionId}"`;
+        const session = {
+            sessionId,
+            startTime: globalThis.performance.now(),
+            label: executionLabel,
+        };
+        this.executionTracker.set(sessionId, session);
+        Capabilities.instance().install(sessionId, this.capabilities);
+        const moduleOutputs = await this.sandbox.runModule(sessionId, operation, this.modules, moduleName, moduleInputs);
+        Capabilities.instance().uninstall(sessionId);
+        this.logExecutionTime(sessionId);
+        return moduleOutputs;
+    }
+    logExecutionTime(sessionId) {
+        const session = this.executionTracker.get(sessionId);
+        if (session) {
+            const duration = globalThis.performance.now() - session.startTime;
+            console.debug?.(`${session.label}: ${duration.toFixed(0)} ms`);
+            this.executionTracker.delete(sessionId);
+        }
+        else {
+            console.warn(`Unable to find timing for "${sessionId}"`);
+        }
+    }
+    async invoke(name, inputs) {
+        return this.executeModule("default", name, inputs);
+    }
+    describe(name, inputs) {
+        return this.executeModule("describe", name, inputs);
+    }
+}

package/dist/src/node-exports.d.ts

@@ -0,0 +1 @@
+export { NodeSandbox } from "./node.js";

package/dist/src/node-exports.js

@@ -0,0 +1 @@
+export { NodeSandbox } from "./node.js";

package/dist/src/node.d.ts

@@ -0,0 +1,18 @@
+import type { ModuleSpec, Sandbox } from "./types.js";
+import type { UUID } from "./types.js";
+export { NodeSandbox };
+declare class NodeSandbox implements Sandbox {
+    private readonly runtimeBuffer;
+    private sandbox;
+    constructor(buffer?: Buffer);
+    initializeTreeSitter(locateFile: (path: string) => string): Promise<void>;
+    setupParser(lang: string, path: string): Promise<void>;
+    private getWasmInstance;
+    getWasmExports(): Promise<{
+        scanFind: (src: string, configs: any[]) => any;
+        scanFix: (src: string, configs: any[]) => string;
+        dumpASTNodes: (src: string) => any;
+        dumpPattern: (src: string, selector?: string | null) => any;
+    }>;
+    runModule(sessionId: UUID, operation: "default" | "describe", moduleRegistry: ModuleSpec, moduleName: string, moduleInputs: Record<string, unknown>): Promise<any>;
+}

package/dist/src/node.js

@@ -0,0 +1,69 @@
+import { ConsoleStdout, OpenFile, WASI, File as WasiFile, } from "@bjorn3/browser_wasi_shim";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import factory from "./factory.js";
+export { NodeSandbox };
+async function loadWasmRuntime() {
+    const wasmFile = import.meta.resolve("@codemod-com/codemod-sandbox/sandbox.wasm");
+    return readFile(fileURLToPath(wasmFile));
+}
+class NodeSandbox {
+    runtimeBuffer;
+    sandbox = null;
+    constructor(buffer) {
+        this.runtimeBuffer = buffer ? Promise.resolve(buffer) : loadWasmRuntime();
+    }
+    async initializeTreeSitter(locateFile) {
+        const instance = await this.getWasmInstance();
+        await instance.Parser.init({ locateFile });
+    }
+    async setupParser(lang, path) {
+        const instance = await this.getWasmInstance();
+        return instance.setupParser(lang, path);
+    }
+    async getWasmInstance() {
+        if (this.sandbox) {
+            return this.sandbox;
+        }
+        const wasmBytes = await this.runtimeBuffer;
+        const wasiInstance = new WASI([], [], [
+            new OpenFile(new WasiFile([])), // stdin
+            ConsoleStdout.lineBuffered((message) => console.log(`[WASI stdout] ${message}`)),
+            ConsoleStdout.lineBuffered((message) => console.warn(`[WASI stderr] ${message}`)),
+        ]);
+        const sandboxFactory = factory();
+        const { instance } = await WebAssembly.instantiate(wasmBytes, {
+            "./codemod-sandbox_bg.js": sandboxFactory,
+            wasi_snapshot_preview1: wasiInstance.wasiImport,
+        });
+        sandboxFactory.__wbg_set_wasm(instance.exports);
+        // @ts-expect-error 2739
+        wasiInstance.start({ exports: instance.exports });
+        if (typeof sandboxFactory.__wbindgen_init_externref_table === "function") {
+            sandboxFactory.__wbindgen_init_externref_table();
+        }
+        else {
+            console.warn("Heap system detected - ensure factory.js has proper heap setup");
+        }
+        this.sandbox = sandboxFactory;
+        return this.sandbox;
+    }
+    async getWasmExports() {
+        const instance = await this.getWasmInstance();
+        return {
+            scanFind: instance.scanFind,
+            scanFix: instance.scanFix,
+            dumpASTNodes: instance.dumpASTNodes,
+            dumpPattern: instance.dumpPattern,
+        };
+    }
+    async runModule(sessionId, operation, moduleRegistry, moduleName, moduleInputs) {
+        const moduleCode = moduleRegistry[moduleName];
+        if (!moduleCode) {
+            return { $error: `Unable to find module "${moduleName}"` };
+        }
+        const instance = await this.getWasmInstance();
+        const executionResult = await instance.run_module(sessionId, operation, moduleName, moduleRegistry, moduleCode, JSON.stringify(moduleInputs));
+        return JSON.parse(executionResult);
+    }
+}

package/dist/src/telemetry.d.ts

@@ -0,0 +1,16 @@
+export { Telemetry };
+interface TelemetryConfig {
+    enabled?: boolean;
+    path?: number[];
+}
+declare class Telemetry {
+    private readonly config;
+    private operationCounter;
+    static create(config: TelemetryConfig): undefined;
+    constructor(config: TelemetryConfig);
+    startModule(): Promise<void>;
+    startCapability(): Promise<number>;
+    endCapability(): Promise<void>;
+    endModule(): Promise<void>;
+    invocationPath(path: number): number[];
+}

package/dist/src/telemetry.js

@@ -0,0 +1,28 @@
+// Simplified telemetry implementation - functionality removed per requirements
+export { Telemetry };
+class Telemetry {
+    config;
+    operationCounter = 0;
+    static create(config) {
+        // Always return undefined to effectively disable telemetry
+        return undefined;
+    }
+    constructor(config) {
+        this.config = { enabled: false, ...config };
+    }
+    async startModule() {
+        // No-op implementation
+    }
+    async startCapability() {
+        return ++this.operationCounter;
+    }
+    async endCapability() {
+        // No-op implementation
+    }
+    async endModule() {
+        // No-op implementation
+    }
+    invocationPath(path) {
+        return [...(this.config.path || []), path];
+    }
+}

package/dist/src/type-declarations.d.ts

@@ -0,0 +1 @@
+export declare const typeDeclarations = "\n/**\n * Encodes a text string as a valid component of a Uniform Resource Identifier (URI).\n * @param uriComponent A value representing an unencoded URI component.\n */\ndeclare function encodeURIComponent(\n  uriComponent: string | number | boolean\n): string;\n\ndeclare function btoa(s: string | Uint8Array): string;\ndeclare function atob(s: string): string;\n\ninterface Console {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  log(...data: any[]);\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  error(...data: any[]);\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  warn(...data: any[]);\n}\n\n// eslint-disable-next-line no-var\ndeclare var console: Console;\n";

package/dist/src/type-declarations.js

@@ -0,0 +1,26 @@
+// THIS FILE IS GENERATED BY update-type-declarations.ts
+// DO NOT EDIT DIRECTLY
+export const typeDeclarations = `
+/**
+ * Encodes a text string as a valid component of a Uniform Resource Identifier (URI).
+ * @param uriComponent A value representing an unencoded URI component.
+ */
+declare function encodeURIComponent(
+  uriComponent: string | number | boolean
+): string;
+
+declare function btoa(s: string | Uint8Array): string;
+declare function atob(s: string): string;
+
+interface Console {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  log(...data: any[]);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  error(...data: any[]);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  warn(...data: any[]);
+}
+
+// eslint-disable-next-line no-var
+declare var console: Console;
+`;

package/dist/src/types.d.ts

@@ -0,0 +1,26 @@
+export type Values = Record<string, unknown>;
+export type OutputValues = Values;
+export type ModuleSpec = Record<string, string>;
+export type ModuleMethod = "default" | "describe";
+export type UUID = `${string}-${string}-${string}-${string}-${string}`;
+export type DescriberInputs = {
+    inputs?: Values;
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+    asType?: boolean;
+};
+export type DescriberOutputs = {
+    inputSchema: unknown;
+    outputSchema: unknown;
+};
+export type InvokeInputs = Values;
+export type InvokeOutputs = Values;
+export type CapabilityFunction = (inputs: Values, path: number[]) => Promise<Values | undefined>;
+export type CapabilityRegistry = {
+    fetch?: CapabilityFunction;
+};
+export type Capability = CapabilityFunction;
+export type CapabilitySpec = CapabilityRegistry;
+export type Sandbox = {
+    runModule(invocationId: UUID, method: "default" | "describe", modules: ModuleSpec, name: string, inputs: Record<string, unknown>): Promise<InvokeOutputs | DescriberOutputs>;
+};

package/dist/src/types.js

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

package/dist/src/web-exports.d.ts

@@ -0,0 +1 @@
+export { WebSandbox } from "./web.js";

package/dist/src/web-exports.js

@@ -0,0 +1 @@
+export { WebSandbox } from "./web.js";

package/dist/src/web.d.ts

@@ -0,0 +1,18 @@
+import type { InvokeInputs, ModuleSpec, Sandbox } from "./types.js";
+import type { UUID } from "./types.js";
+export { WebSandbox };
+declare class WebSandbox implements Sandbox {
+    readonly runtimeUrl: URL;
+    private readonly sandboxInstance;
+    constructor(runtimeUrl: URL);
+    getWasmExports(): Promise<{
+        scanFind: (src: string, configs: any[]) => any;
+        scanFix: (src: string, configs: any[]) => string;
+        dumpASTNodes: (src: string) => any;
+        dumpPattern: (src: string, selector?: string | null) => any;
+    }>;
+    private initializeSandbox;
+    initializeTreeSitter(): Promise<void>;
+    setupParser(lang: string, path: string): Promise<void>;
+    runModule(sessionId: UUID, operation: "default" | "describe", moduleRegistry: ModuleSpec, moduleName: string, moduleInputs: InvokeInputs): Promise<any>;
+}

package/dist/src/web.js

@@ -0,0 +1,91 @@
+import { ConsoleStdout, OpenFile, WASI, File as WasiFile, } from "@bjorn3/browser_wasi_shim";
+import factory from "./factory.js";
+export { WebSandbox };
+class WebSandbox {
+    runtimeUrl;
+    sandboxInstance;
+    constructor(runtimeUrl) {
+        this.runtimeUrl = runtimeUrl;
+        this.sandboxInstance = this.initializeSandbox();
+    }
+    async getWasmExports() {
+        const result = await this.sandboxInstance;
+        return {
+            scanFind: result.scanFind,
+            scanFix: result.scanFix,
+            dumpASTNodes: result.dumpASTNodes,
+            dumpPattern: result.dumpPattern,
+        };
+    }
+    async initializeSandbox() {
+        const wasiRuntime = new WASI([], [], [
+            new OpenFile(new WasiFile([])), // stdin
+            ConsoleStdout.lineBuffered((message) => console.log(`[WASI stdout] ${message}`)),
+            ConsoleStdout.lineBuffered((message) => console.warn(`[WASI stderr] ${message}`)),
+        ]);
+        const sandboxFactory = factory();
+        const { instance } = await WebAssembly.instantiateStreaming(fetch(this.runtimeUrl), {
+            "./codemod-sandbox_bg.js": sandboxFactory,
+            wasi_snapshot_preview1: wasiRuntime.wasiImport,
+        });
+        sandboxFactory.__wbg_set_wasm(instance.exports);
+        if (typeof sandboxFactory.__wbindgen_init_externref_table === "function") {
+            sandboxFactory.__wbindgen_init_externref_table();
+        }
+        else {
+            console.warn("Heap system detected - ensure factory.js has proper heap setup");
+        }
+        // @ts-expect-error 2739
+        wasiRuntime.start({ exports: instance.exports });
+        return sandboxFactory;
+    }
+    async initializeTreeSitter() {
+        const sandbox = await this.sandboxInstance;
+        return sandbox.Parser.init();
+    }
+    async setupParser(lang, path) {
+        const sandbox = await this.sandboxInstance;
+        return sandbox.setupParser(lang, path);
+    }
+    async runModule(sessionId, operation, moduleRegistry, moduleName, moduleInputs) {
+        const sandboxInstance = await this.sandboxInstance;
+        const moduleCode = moduleRegistry[moduleName];
+        if (!moduleCode) {
+            return { $error: `Unable to find module "${moduleName}"` };
+        }
+        const inputData = JSON.stringify(moduleInputs);
+        console.debug(...formatDataSize(`Run module: "${moduleName}": input size`, inputData.length));
+        const executionResult = await sandboxInstance.run_module(sessionId, operation, moduleName, moduleRegistry, moduleCode, inputData);
+        return JSON.parse(executionResult);
+    }
+}
+function formatDataSize(prefix, sizeInBytes) {
+    if (!Number.isInteger(sizeInBytes)) {
+        console.warn("formatDataSize: Input number should be an integer. Proceeding with the given value.");
+    }
+    const kilobyte = 1024;
+    const sizeUnits = ["Bytes", "KiB", "MiB", "GiB", "TiB"];
+    const colorStyles = [
+        "color:darkgray",
+        "color:blue",
+        "color:red;font-weight:bold",
+        "color:red;font-weight:bold",
+        "color:red;font-weight:bold",
+    ];
+    if (sizeInBytes === 0) {
+        return ["%c0", "color: lightgray", "Bytes"];
+    }
+    let currentSize = sizeInBytes;
+    let unitIndex = 0;
+    while (currentSize >= kilobyte && unitIndex < sizeUnits.length - 1) {
+        currentSize /= kilobyte;
+        unitIndex++;
+    }
+    const formattedSize = Number.parseFloat(currentSize.toFixed(2));
+    let unitLabel = sizeUnits[unitIndex];
+    const consoleStyle = colorStyles[unitIndex];
+    if (currentSize === 1) {
+        unitLabel = "Byte";
+    }
+    return [`${prefix} %c${formattedSize}`, consoleStyle, unitLabel];
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@codemod.com/codemod-sandbox",
+  "version": "0.1.0",
+  "description": "Codemod Javascript Sandbox",
+  "main": "./dist/src/index.js",
+  "exports": {
+    ".": "./dist/src/index.js",
+    "./sandbox.wasm": "./sandbox.wasm",
+    "./web": "./dist/src/web-exports.js",
+    "./node": "./dist/src/node-exports.js"
+  },
+  "types": "dist/src/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "prepack": "pnpm run build",
+    "build:rs": "cd ../.. && cargo run -p codemod-sandbox-build --color=always -- -r",
+    "copy-runtime-files": "pnpm run build:rs && tsx scripts/copy-runtime-files.ts",
+    "generate-type-declarations": "tsx scripts/generate-type-declarations.ts",
+    "build:tsc": "pnpm run generate-type-declarations && tsc --project tsconfig.build.json --pretty",
+    "build:runtime": "pnpm run copy-runtime-files",
+    "build": "pnpm run build:runtime && pnpm run build:tsc",
+    "lint": "pnpm run build:tsc && eslint src/ --ext .ts",
+    "test": "pnpm run build && node --test --enable-source-maps --test-reporter spec dist/tests/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/codemod-com/codemod"
+  },
+  "files": [
+    "dist/src",
+    "sandbox.wasm"
+  ],
+  "keywords": [],
+  "devDependencies": {
+    "@tsconfig/node22": "^22.0.2",
+    "@types/node": "^22.0.0",
+    "eslint": "^8.57.1",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@bjorn3/browser_wasi_shim": "^0.4.1",
+    "web-tree-sitter": "^0.25.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "packageManager": "pnpm@10.4.1+sha512.c753b6c3ad7afa13af388fa6d808035a008e30ea9993f58c6663e2bc5ff21679aa834db094987129aa4d488b86df57f7b634981b2f827cdcacc698cc0cfb88af"
+}