@capsule-run/sdk 0.4.2 → 0.5.1

package/dist/polyfills/url.d.ts

@@ -0,0 +1,47 @@
+/**
+ * URL polyfill for WASI environment
+ * Aliases Node.js 'url' module to native Web URL APIs
+ */
+export declare const URL: {
+    new (url: string | URL, base?: string | URL): URL;
+    prototype: URL;
+    canParse(url: string | URL, base?: string | URL): boolean;
+    createObjectURL(obj: Blob | MediaSource): string;
+    parse(url: string | URL, base?: string | URL): URL | null;
+    revokeObjectURL(url: string): void;
+};
+export declare const URLSearchParams: {
+    new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
+    prototype: URLSearchParams;
+};
+/**
+ * Legacy Node.js url.parse()
+ */
+export declare function parse(urlString: string, parseQueryString?: boolean): any;
+/**
+ * Legacy Node.js url.format()
+ */
+export declare function format(urlObject: any): string;
+/**
+ * Legacy Node.js url.resolve()
+ */
+export declare function resolve(from: string, to: string): string;
+declare const url: {
+    URL: {
+        new (url: string | URL, base?: string | URL): URL;
+        prototype: URL;
+        canParse(url: string | URL, base?: string | URL): boolean;
+        createObjectURL(obj: Blob | MediaSource): string;
+        parse(url: string | URL, base?: string | URL): URL | null;
+        revokeObjectURL(url: string): void;
+    };
+    URLSearchParams: {
+        new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
+        prototype: URLSearchParams;
+    };
+    parse: typeof parse;
+    format: typeof format;
+    resolve: typeof resolve;
+};
+export default url;
+//# sourceMappingURL=url.d.ts.map

package/dist/polyfills/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../src/polyfills/url.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,GAAG;;;;;;;CAAiB,CAAC;AAElC,eAAO,MAAM,eAAe;;;CAA6B,CAAC;AAE1D;;GAEG;AACH,wBAAgB,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,OAAO,GAAG,GAAG,CAiBxE;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,GAAG,GAAG,MAAM,CAiB7C;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAMxD;AAED,QAAA,MAAM,GAAG;;;;;;;;;;;;;;;;CAMR,CAAC;AAEF,eAAe,GAAG,CAAC"}

package/dist/polyfills/url.js

@@ -0,0 +1,68 @@
+/**
+ * URL polyfill for WASI environment
+ * Aliases Node.js 'url' module to native Web URL APIs
+ */
+export const URL = globalThis.URL;
+export const URLSearchParams = globalThis.URLSearchParams;
+/**
+ * Legacy Node.js url.parse()
+ */
+export function parse(urlString, parseQueryString) {
+    try {
+        const url = new URL(urlString);
+        return {
+            href: url.href,
+            protocol: url.protocol,
+            host: url.host,
+            hostname: url.hostname,
+            port: url.port,
+            pathname: url.pathname,
+            search: url.search,
+            hash: url.hash,
+            query: parseQueryString ? Object.fromEntries(url.searchParams) : url.search.slice(1),
+        };
+    }
+    catch (e) {
+        return null;
+    }
+}
+/**
+ * Legacy Node.js url.format()
+ */
+export function format(urlObject) {
+    if (typeof urlObject === 'string') {
+        return urlObject;
+    }
+    try {
+        const protocol = urlObject.protocol || 'http:';
+        const hostname = urlObject.hostname || urlObject.host || 'localhost';
+        const port = urlObject.port ? `:${urlObject.port}` : '';
+        const pathname = urlObject.pathname || '/';
+        const search = urlObject.search || '';
+        const hash = urlObject.hash || '';
+        return `${protocol}//${hostname}${port}${pathname}${search}${hash}`;
+    }
+    catch (e) {
+        return '';
+    }
+}
+/**
+ * Legacy Node.js url.resolve()
+ */
+export function resolve(from, to) {
+    try {
+        return new URL(to, from).href;
+    }
+    catch (e) {
+        return to;
+    }
+}
+const url = {
+    URL,
+    URLSearchParams,
+    parse,
+    format,
+    resolve,
+};
+export default url;
+//# sourceMappingURL=url.js.map

package/dist/polyfills/url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.js","sourceRoot":"","sources":["../../src/polyfills/url.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC;AAElC,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC;AAE1D;;GAEG;AACH,MAAM,UAAU,KAAK,CAAC,SAAiB,EAAE,gBAA0B;IAC/D,IAAI,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;QAC/B,OAAO;YACH,IAAI,EAAE,GAAG,CAAC,IAAI;YACd,QAAQ,EAAE,GAAG,CAAC,QAAQ;YACtB,IAAI,EAAE,GAAG,CAAC,IAAI;YACd,QAAQ,EAAE,GAAG,CAAC,QAAQ;YACtB,IAAI,EAAE,GAAG,CAAC,IAAI;YACd,QAAQ,EAAE,GAAG,CAAC,QAAQ;YACtB,MAAM,EAAE,GAAG,CAAC,MAAM;YAClB,IAAI,EAAE,GAAG,CAAC,IAAI;YACd,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;SACvF,CAAC;IACN,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACT,OAAO,IAAI,CAAC;IAChB,CAAC;AACL,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,MAAM,CAAC,SAAc;IACjC,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;QAChC,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,IAAI,CAAC;QACD,MAAM,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,OAAO,CAAC;QAC/C,MAAM,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,SAAS,CAAC,IAAI,IAAI,WAAW,CAAC;QACrE,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACxD,MAAM,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,GAAG,CAAC;QAC3C,MAAM,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,EAAE,CAAC;QAElC,OAAO,GAAG,QAAQ,KAAK,QAAQ,GAAG,IAAI,GAAG,QAAQ,GAAG,MAAM,GAAG,IAAI,EAAE,CAAC;IACxE,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACT,OAAO,EAAE,CAAC;IACd,CAAC;AACL,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,OAAO,CAAC,IAAY,EAAE,EAAU;IAC5C,IAAI,CAAC;QACD,OAAO,IAAI,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC;IAClC,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACT,OAAO,EAAE,CAAC;IACd,CAAC;AACL,CAAC;AAED,MAAM,GAAG,GAAG;IACR,GAAG;IACH,eAAe;IACf,KAAK;IACL,MAAM;IACN,OAAO;CACV,CAAC;AAEF,eAAe,GAAG,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capsule-run/sdk",
-  "version": "0.4.2",
+  "version": "0.5.1",
   "description": "Capsule JavaScript SDK - run AI agent tasks in secure WASM sandboxes",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,24 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@bytecodealliance/jco": "^1.0.0",
+    "buffer": "^6.0.3",
     "esbuild": "^0.27.2",
+    "events": "^3.3.0",
+    "path-browserify": "^1.0.1",
+    "readable-stream": "^4.7.0",
     "typescript": "^5.9.3"
+  },
+  "devDependencies": {
+    "@types/events": "^3.0.3",
+    "@types/path-browserify": "^1.0.3",
+    "@types/readable-stream": "^4.0.18"
+  },
+  "peerDependencies": {
+    "@types/node": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "@types/node": {
+      "optional": true
+    }
   }
 }

package/src/index.ts

@@ -16,7 +16,9 @@
 
 export { task, type TaskOptions } from "./task.js";
 export { TaskRunner, exports, type TaskConfig } from "./app.js";
-export * as files from "./files.js";
-export * as env from "./env.js";
+export { default as fs } from "./polyfills/fs.js";
 export { isWasmMode } from "./hostApi.js";
+export { default as path } from "./polyfills/path.js";
+export { default as os } from "./polyfills/os.js";
+export { default as process } from "./polyfills/process.js";
 

package/src/polyfills/buffer.ts

@@ -0,0 +1,11 @@
+/**
+ * Buffer polyfill for WASI environment
+ * Provides Node.js-compatible Buffer class using the buffer package
+ */
+
+import { Buffer as BufferPolyfill } from 'buffer';
+
+(globalThis as any).Buffer = BufferPolyfill;
+
+export const Buffer = BufferPolyfill;
+export default BufferPolyfill;

package/src/polyfills/events.ts

@@ -0,0 +1,11 @@
+/**
+ * Events polyfill for WASI environment
+ * Provides Node.js-compatible EventEmitter using the events package
+ */
+
+import EventEmitter from 'events';
+
+(globalThis as any).EventEmitter = EventEmitter;
+
+export { EventEmitter };
+export default EventEmitter;

package/src/polyfills/fs-promises.ts

@@ -0,0 +1,7 @@
+/**
+ * fs/promises polyfill for WASI environment
+ * Allows: import fs from 'fs/promises'
+ */
+
+export { promises as default } from './fs.js';
+export * from './fs.js';

package/src/polyfills/fs.ts

@@ -0,0 +1,336 @@
+/**
+ * Node.js fs polyfill for WASI environment
+ * Provides both Node.js fs API
+ */
+
+declare const globalThis: {
+    'wasi:filesystem/types': any;
+    'wasi:filesystem/preopens': any;
+};
+
+interface Descriptor {
+    read(length: bigint, offset: bigint): [Uint8Array, boolean];
+    write(buffer: Uint8Array, offset: bigint): bigint;
+    stat(): { size: bigint };
+    readDirectory(): any;
+    openAt(
+        pathFlags: { symlinkFollow?: boolean },
+        path: string,
+        openFlags: { create?: boolean; directory?: boolean; exclusive?: boolean; truncate?: boolean },
+        descriptorFlags: { read?: boolean; write?: boolean; mutateDirectory?: boolean }
+    ): Descriptor;
+}
+
+interface PreopenedDir {
+    descriptor: Descriptor;
+    guestPath: string;
+}
+
+function getFsBindings(): { types: any; preopens: any } | null {
+    try {
+        const types = globalThis['wasi:filesystem/types'];
+        const preopens = globalThis['wasi:filesystem/preopens'];
+        if (types && preopens) {
+            return { types, preopens };
+        }
+    } catch {}
+    return null;
+}
+
+function getPreopenedDirs(): PreopenedDir[] {
+    const fs = getFsBindings();
+    if (!fs) return [];
+
+    try {
+        const dirs = fs.preopens.getDirectories();
+        return (dirs || []).map((entry: [Descriptor, string]) => ({
+            descriptor: entry[0],
+            guestPath: entry[1]
+        }));
+    } catch {
+        return [];
+    }
+}
+
+function normalizePath(path: string): string {
+    if (path.startsWith('./')) {
+        return path.slice(2);
+    }
+    return path;
+}
+
+function resolvePath(path: string): { dir: Descriptor; relativePath: string } | null {
+    const preopens = getPreopenedDirs();
+    if (preopens.length === 0) return null;
+
+    const normalizedPath = normalizePath(path);
+
+    for (const { descriptor, guestPath } of preopens) {
+        const normalizedGuest = normalizePath(guestPath);
+
+        if (normalizedGuest === '.' || normalizedGuest === '') {
+            return { dir: descriptor, relativePath: normalizedPath };
+        }
+
+        if (normalizedPath.startsWith(normalizedGuest + '/')) {
+            const relativePath = normalizedPath.slice(normalizedGuest.length + 1);
+            return { dir: descriptor, relativePath };
+        }
+
+        if (normalizedPath === normalizedGuest) {
+            return { dir: descriptor, relativePath: '.' };
+        }
+    }
+
+    return { dir: preopens[0].descriptor, relativePath: normalizedPath };
+}
+
+/**
+ * Read a file as text.
+ */
+export async function readText(path: string): Promise<string> {
+    const bytes = await readBytes(path);
+    return new TextDecoder().decode(bytes);
+}
+
+/**
+ * Read a file as bytes.
+ */
+export async function readBytes(path: string): Promise<Uint8Array> {
+    const resolved = resolvePath(path);
+    if (!resolved) {
+        throw new Error("Filesystem not available.");
+    }
+
+    try {
+        const pathFlags = { symlinkFollow: false };
+        const openFlags = {};
+        const descriptorFlags = { read: true };
+
+        const fd = resolved.dir.openAt(pathFlags, resolved.relativePath, openFlags, descriptorFlags);
+        const stat = fd.stat();
+        const [data] = fd.read(stat.size, BigInt(0));
+        return data;
+    } catch (e) {
+        throw new Error(`Failed to read file '${path}': ${e}`);
+    }
+}
+
+/**
+ * Write text content to a file.
+ */
+export async function writeText(path: string, content: string): Promise<void> {
+    const bytes = new TextEncoder().encode(content);
+    await writeBytes(path, bytes);
+}
+
+/**
+ * Write bytes to a file.
+ */
+export async function writeBytes(path: string, data: Uint8Array): Promise<void> {
+    const resolved = resolvePath(path);
+    if (!resolved) {
+        throw new Error("Filesystem not available.");
+    }
+
+    try {
+        const pathFlags = { symlinkFollow: false };
+        const openFlags = { create: true, truncate: true };
+        const descriptorFlags = { write: true };
+
+        const fd = resolved.dir.openAt(pathFlags, resolved.relativePath, openFlags, descriptorFlags);
+        fd.write(data, BigInt(0));
+    } catch (e) {
+        throw new Error(`Failed to write file '${path}': ${e}`);
+    }
+}
+
+/**
+ * List files/directories at a path.
+ */
+export async function list(path: string = "."): Promise<string[]> {
+    const resolved = resolvePath(path);
+    if (!resolved) {
+        throw new Error("Filesystem not available.");
+    }
+
+    try {
+        let targetDir = resolved.dir;
+        if (resolved.relativePath !== ".") {
+            const pathFlags = { symlinkFollow: false };
+            const openFlags = { directory: true };
+            const descriptorFlags = { read: true };
+            targetDir = resolved.dir.openAt(pathFlags, resolved.relativePath, openFlags, descriptorFlags);
+        }
+
+        const stream = targetDir.readDirectory();
+        const entries: string[] = [];
+
+        let entry;
+        while ((entry = stream.readDirectoryEntry()) && entry) {
+            if (entry.name) {
+                entries.push(entry.name);
+            }
+        }
+
+        return entries;
+    } catch (e) {
+        throw new Error(`Failed to list directory '${path}': ${e}`);
+    }
+}
+
+/**
+ * Check if a file or directory exists.
+ */
+export async function exists(path: string): Promise<boolean> {
+    const resolved = resolvePath(path);
+    if (!resolved) {
+        return false;
+    }
+
+    try {
+        const pathFlags = { symlinkFollow: false };
+        const openFlags = {};
+        const descriptorFlags = { read: true };
+        resolved.dir.openAt(pathFlags, resolved.relativePath, openFlags, descriptorFlags);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+type Encoding = 'utf8' | 'utf-8' | 'buffer' | null | undefined;
+
+interface ReadFileOptions {
+    encoding?: Encoding;
+}
+
+interface WriteFileOptions {
+    encoding?: Encoding;
+}
+
+/**
+ * Read file contents (async/callback style)
+ */
+export function readFile(
+    path: string,
+    optionsOrCallback: ReadFileOptions | Encoding | ((err: Error | null, data?: string | Uint8Array) => void),
+    callback?: (err: Error | null, data?: string | Uint8Array) => void
+): void {
+    let options: ReadFileOptions = {};
+    let cb: ((err: Error | null, data?: string | Uint8Array) => void) | undefined;
+
+    if (typeof optionsOrCallback === 'function') {
+        cb = optionsOrCallback;
+    } else if (typeof optionsOrCallback === 'string') {
+        options = { encoding: optionsOrCallback as Encoding };
+        cb = callback;
+    } else if (optionsOrCallback) {
+        options = optionsOrCallback;
+        cb = callback;
+    }
+
+    const encoding = options.encoding;
+    const isText = encoding === 'utf8' || encoding === 'utf-8';
+
+    const promise = isText ? readText(path) : readBytes(path);
+
+    promise
+        .then((data) => cb?.(null, data))
+        .catch((err) => cb?.(err instanceof Error ? err : new Error(String(err))));
+}
+
+/**
+ * Write file contents (async/callback style)
+ */
+export function writeFile(
+    path: string,
+    data: string | Uint8Array,
+    optionsOrCallback: WriteFileOptions | Encoding | ((err: Error | null) => void),
+    callback?: (err: Error | null) => void
+): void {
+    const cb: ((err: Error | null) => void) | undefined =
+        typeof optionsOrCallback === 'function' ? optionsOrCallback : callback;
+
+    const promise = typeof data === 'string'
+        ? writeText(path, data)
+        : writeBytes(path, data);
+
+    promise
+        .then(() => cb?.(null))
+        .catch((err) => cb?.(err instanceof Error ? err : new Error(String(err))));
+}
+
+/**
+ * Read directory contents (async/callback style)
+ */
+export function readdir(
+    path: string,
+    optionsOrCallback: any | ((err: Error | null, files?: string[]) => void),
+    callback?: (err: Error | null, files?: string[]) => void
+): void {
+    const cb = typeof optionsOrCallback === 'function' ? optionsOrCallback : callback;
+
+    list(path)
+        .then((files) => cb?.(null, files))
+        .catch((err) => cb?.(err instanceof Error ? err : new Error(String(err))));
+}
+
+/**
+ * Check if file/directory exists (sync-style, limited in WASM)
+ */
+export function existsSync(_path: string): boolean {
+    console.warn('fs.existsSync: Cannot implement true sync in WASM. Use fs.access instead.');
+    return false;
+}
+
+/**
+ * Promises API
+ */
+export const promises = {
+    async readFile(path: string, options?: ReadFileOptions | Encoding): Promise<string | Uint8Array> {
+        const encoding = typeof options === 'string' ? options : options?.encoding;
+        const isText = encoding === 'utf8' || encoding === 'utf-8';
+        return isText ? readText(path) : readBytes(path);
+    },
+
+    async writeFile(path: string, data: string | Uint8Array): Promise<void> {
+        if (typeof data === 'string') {
+            await writeText(path, data);
+        } else {
+            await writeBytes(path, data);
+        }
+    },
+
+    async readdir(path: string): Promise<string[]> {
+        return list(path);
+    },
+
+    async access(path: string): Promise<void> {
+        const fileExists = await exists(path);
+        if (!fileExists) {
+            throw new Error(`ENOENT: no such file or directory, access '${path}'`);
+        }
+    },
+
+    async stat(path: string): Promise<{ isFile: () => boolean; isDirectory: () => boolean }> {
+        const fileExists = await exists(path);
+        if (!fileExists) {
+            throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
+        }
+        return {
+            isFile: () => true,
+            isDirectory: () => false,
+        };
+    },
+};
+
+const fs = {
+    readFile,
+    writeFile,
+    readdir,
+    existsSync,
+    promises,
+};
+
+export default fs;