@capsule-run/sdk 0.4.2 → 0.5.1

package/src/polyfills/os.ts

@@ -0,0 +1,222 @@
+/**
+ * OS polyfill
+ * Provides Node.js-compatible os object
+ */
+
+interface CpuInfo {
+    model: string;
+    speed: number;
+    times: {
+        user: number;
+        nice: number;
+        sys: number;
+        idle: number;
+        irq: number;
+    };
+}
+
+interface NetworkInterface {
+    address: string;
+    netmask: string;
+    family: string;
+    mac: string;
+    internal: boolean;
+    cidr: string | null;
+}
+
+const os = {
+    /**
+     * Returns the operating system platform
+     * WASI is POSIX-like, so we return 'linux'
+     */
+    platform(): 'aix' | 'darwin' | 'freebsd' | 'linux' | 'openbsd' | 'sunos' | 'win32' {
+        return 'linux';
+    },
+
+    /**
+     * Returns the CPU architecture
+     * WASM runs on wasm32 architecture
+     */
+    arch(): string {
+        return 'wasm32';
+    },
+
+    /**
+     * Returns the operating system's default directory for temporary files
+     */
+    tmpdir(): string {
+        return '/tmp';
+    },
+
+    /**
+     * Returns the home directory of the current user
+     */
+    homedir(): string {
+        return '/home/capsule';
+    },
+
+    /**
+     * Returns the system uptime in seconds
+     * Not available in WASI, returns 0
+     */
+    uptime(): number {
+        return 0;
+    },
+
+    /**
+     * Returns the amount of free system memory in bytes
+     * Not available in WASI, returns 0
+     */
+    freemem(): number {
+        return 0;
+    },
+
+    /**
+     * Returns the total amount of system memory in bytes
+     * Not available in WASI, returns 0
+     */
+    totalmem(): number {
+        return 0;
+    },
+
+    /**
+     * Returns an array of objects containing information about each CPU/core
+     * Not available in WASI, returns empty array
+     */
+    cpus(): CpuInfo[] {
+        return [];
+    },
+
+    /**
+     * Returns the hostname of the operating system
+     */
+    hostname(): string {
+        return 'capsule-wasm';
+    },
+
+    /**
+     * Returns the operating system release
+     */
+    release(): string {
+        return 'wasi';
+    },
+
+    /**
+     * Returns the operating system type
+     */
+    type(): string {
+        return 'WASI';
+    },
+
+    /**
+     * Returns the endianness of the CPU
+     * WASM is little-endian
+     */
+    endianness(): 'BE' | 'LE' {
+        return 'LE';
+    },
+
+    /**
+     * Returns an object containing network interfaces
+     * Not available in WASI, returns empty object
+     */
+    networkInterfaces(): { [index: string]: NetworkInterface[] } {
+        return {};
+    },
+
+    /**
+     * Returns the operating system's default directory for user data
+     */
+    userInfo(options?: { encoding: 'buffer' }): {
+        username: string;
+        uid: number;
+        gid: number;
+        shell: string | null;
+        homedir: string;
+    } {
+        return {
+            username: 'capsule',
+            uid: 1000,
+            gid: 1000,
+            shell: null,
+            homedir: '/home/capsule',
+        };
+    },
+
+    /**
+     * Returns an array of objects containing information about the load average
+     * Not available in WASI, returns [0, 0, 0]
+     */
+    loadavg(): number[] {
+        return [0, 0, 0];
+    },
+
+    /**
+     * Returns the operating system's version
+     */
+    version(): string {
+        return 'WASI 0.2';
+    },
+
+    /**
+     * Returns the machine type
+     */
+    machine(): string {
+        return 'wasm32';
+    },
+
+    /**
+     * Platform-specific path segment separator
+     */
+    get EOL(): string {
+        return '\n';
+    },
+
+    /**
+     * Platform-specific constants
+     */
+    constants: {
+        signals: {},
+        errno: {},
+        priority: {},
+    },
+
+    /**
+     * Returns the number of logical CPU cores
+     * Not available in WASI, returns 1
+     */
+    availableParallelism(): number {
+        return 1;
+    },
+
+    /**
+     * Returns the string path of the current user's home directory
+     */
+    devNull: '/dev/null',
+};
+
+export default os;
+
+export const {
+    platform,
+    arch,
+    tmpdir,
+    homedir,
+    uptime,
+    freemem,
+    totalmem,
+    cpus,
+    hostname,
+    release,
+    type,
+    endianness,
+    networkInterfaces,
+    userInfo,
+    loadavg,
+    version,
+    machine,
+    EOL,
+    constants,
+    availableParallelism,
+    devNull,
+} = os;

package/src/polyfills/path.ts

@@ -0,0 +1,21 @@
+/**
+ * Path polyfill
+ * Provides Node.js-compatible path object
+ */
+
+import path from 'path-browserify';
+
+export default path;
+export const {
+    resolve,
+    join,
+    dirname,
+    basename,
+    extname,
+    format,
+    parse,
+    sep,
+    delimiter,
+    posix,
+    win32
+} = path;

package/src/polyfills/process.ts

@@ -0,0 +1,286 @@
+/**
+ * Process polyfill for WASI environment
+ * Provides Node.js-compatible process object with WASI-backed values
+ */
+
+declare const globalThis: {
+    'wasi:cli/environment': {
+        getEnvironment(): [string, string][];
+        getArguments(): string[];
+        initialCwd(): string | null;
+    };
+};
+
+/**
+ * Internal helper to safely get the WASI environment bindings.
+ */
+function getEnvBindings() {
+    try {
+        const env = globalThis['wasi:cli/environment'];
+
+        if (env && typeof env.getEnvironment === 'function') {
+            return env;
+        }
+    } catch {}
+    return null;
+}
+
+/**
+ * Lazy-loaded environment variables from WASI
+ */
+function getEnv(): Record<string, string> {
+    const bindings = getEnvBindings();
+    if (!bindings) {
+        return {};
+    }
+
+    try {
+        const envPairs = bindings.getEnvironment();
+        return Object.fromEntries(envPairs);
+    } catch (e) {
+        console.error("Failed to fetch environment variables:", e);
+        return {};
+    }
+}
+
+/**
+ * Lazy-loaded command-line arguments from WASI
+ */
+function getArgv(): string[] {
+    const bindings = getEnvBindings();
+    if (!bindings || typeof bindings.getArguments !== 'function') {
+        return ['capsule'];
+    }
+
+    try {
+        return bindings.getArguments();
+    } catch {
+        return ['capsule'];
+    }
+}
+
+/**
+ * Get current working directory from WASI
+ */
+function getCwd(): string {
+    const bindings = getEnvBindings();
+    if (!bindings || typeof bindings.initialCwd !== 'function') {
+        return '/';
+    }
+
+    try {
+        const cwd = bindings.initialCwd();
+        return cwd || '/';
+    } catch {
+        return '/';
+    }
+}
+
+const process = {
+    /**
+     * Environment variables
+     */
+    get env(): Record<string, string> {
+        return getEnv();
+    },
+
+    /**
+     * Command-line arguments
+     */
+    get argv(): string[] {
+        return getArgv();
+    },
+
+    /**
+     * Returns the current working directory
+     */
+    cwd(): string {
+        return getCwd();
+    },
+
+    /**
+     * Change directory (not supported in WASI)
+     */
+    chdir(directory: string): void {
+        throw new Error('process.chdir() is not supported in WASI environment');
+    },
+
+    /**
+     * Platform identifier
+     */
+    get platform(): 'linux' {
+        return 'linux';
+    },
+
+    /**
+     * Architecture identifier
+     */
+    get arch(): 'wasm32' {
+        return 'wasm32';
+    },
+
+    /**
+     * Process ID (not available in WASI)
+     */
+    get pid(): number {
+        return 1;
+    },
+
+    /**
+     * Parent process ID (not available in WASI)
+     */
+    get ppid(): number {
+        return 0;
+    },
+
+    /**
+     * Process uptime in seconds
+     */
+    uptime(): number {
+        return 0;
+    },
+
+    /**
+     * Node.js version (WASI doesn't have Node.js)
+     */
+    get version(): string {
+        return 'v0.0.0-wasi';
+    },
+
+    /**
+     * Node.js versions object
+     */
+    get versions(): Record<string, string> {
+        return {
+            wasi: '0.2.0',
+        };
+    },
+
+    /**
+     * Exit the process (not fully supported in WASI)
+     */
+    exit(code?: number): never {
+        throw new Error(`Process exit requested with code ${code ?? 0}`);
+    },
+
+    /**
+     * Abort the process
+     */
+    abort(): never {
+        throw new Error('Process aborted');
+    },
+
+    /**
+     * Queue a microtask (uses native queueMicrotask)
+     */
+    nextTick(callback: (...args: any[]) => void, ...args: any[]): void {
+        queueMicrotask(() => callback(...args));
+    },
+
+    /**
+     * Standard streams (not fully implemented)
+     */
+    get stdout(): any {
+        return {
+            write: (data: string) => console.log(data),
+            isTTY: false,
+        };
+    },
+
+    get stderr(): any {
+        return {
+            write: (data: string) => console.error(data),
+            isTTY: false,
+        };
+    },
+
+    get stdin(): any {
+        return {
+            isTTY: false,
+        };
+    },
+
+    /**
+     * Memory usage (not available in WASI)
+     */
+    memoryUsage(): {
+        rss: number;
+        heapTotal: number;
+        heapUsed: number;
+        external: number;
+        arrayBuffers: number;
+    } {
+        return {
+            rss: 0,
+            heapTotal: 0,
+            heapUsed: 0,
+            external: 0,
+            arrayBuffers: 0,
+        };
+    },
+
+    /**
+     * CPU usage (not available in WASI)
+     */
+    cpuUsage(previousValue?: { user: number; system: number }): {
+        user: number;
+        system: number;
+    } {
+        return {
+            user: 0,
+            system: 0,
+        };
+    },
+
+    /**
+     * High-resolution time
+     */
+    hrtime: {
+        bigint(): bigint {
+            return BigInt(Date.now() * 1000000);
+        },
+    },
+
+    /**
+     * Execute path
+     */
+    get execPath(): string {
+        return '/usr/bin/capsule';
+    },
+
+    /**
+     * Execution arguments
+     */
+    get execArgv(): string[] {
+        return [];
+    },
+
+    /**
+     * Title (not settable in WASI)
+     */
+    get title(): string {
+        return 'capsule';
+    },
+
+};
+
+export default process;
+
+export const {
+    env,
+    argv,
+    cwd,
+    platform,
+    arch,
+    pid,
+    ppid,
+    version,
+    versions,
+    exit,
+    nextTick,
+    stdout,
+    stderr,
+    stdin,
+} = process;
+
+(globalThis as any).process = process;

package/src/polyfills/stream-web.ts

@@ -0,0 +1,24 @@
+/**
+ * stream/web polyfill for WASI environment
+ * Exports the native Web Streams API which is built into StarlingMonkey
+ */
+
+export const ReadableStream = globalThis.ReadableStream;
+export const WritableStream = globalThis.WritableStream;
+export const TransformStream = globalThis.TransformStream;
+export const ReadableStreamDefaultReader = globalThis.ReadableStreamDefaultReader;
+export const ReadableStreamBYOBReader = (globalThis as any).ReadableStreamBYOBReader;
+export const WritableStreamDefaultWriter = globalThis.WritableStreamDefaultWriter;
+export const ByteLengthQueuingStrategy = globalThis.ByteLengthQueuingStrategy;
+export const CountQueuingStrategy = globalThis.CountQueuingStrategy;
+
+export default {
+    ReadableStream,
+    WritableStream,
+    TransformStream,
+    ReadableStreamDefaultReader,
+    ReadableStreamBYOBReader,
+    WritableStreamDefaultWriter,
+    ByteLengthQueuingStrategy,
+    CountQueuingStrategy,
+};

package/src/polyfills/stream.ts

@@ -0,0 +1,28 @@
+/**
+ * Stream polyfill for WASI environment
+ * Provides Node.js-compatible streams using the readable-stream package
+ */
+
+export {
+    Readable,
+    Writable,
+    Duplex,
+    Transform,
+    PassThrough,
+    Stream,
+    pipeline,
+    finished,
+} from 'readable-stream';
+
+import { Readable, Writable, Duplex, Transform, PassThrough, Stream } from 'readable-stream';
+
+const stream = {
+    Readable,
+    Writable,
+    Duplex,
+    Transform,
+    PassThrough,
+    Stream,
+};
+
+export default stream;

package/src/polyfills/url.ts

@@ -0,0 +1,73 @@
+/**
+ * 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: string, parseQueryString?: boolean): any {
+    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: any): string {
+    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: string, to: string): string {
+    try {
+        return new URL(to, from).href;
+    } catch (e) {
+        return to;
+    }
+}
+
+const url = {
+    URL,
+    URLSearchParams,
+    parse,
+    format,
+    resolve,
+};
+
+export default url;

package/dist/env.d.ts

@@ -1,22 +0,0 @@
-/**
- * Capsule Environment API for WASM environment variables access.
- * Based on wasi:cli/environment@0.2.0
- */
-/**
- * Returns all environment variables as an object.
- * * @returns An object where keys are variable names and values are their values.
- * @example { "PORT": "8080" }
- */
-export declare function getAll(): Record<string, string>;
-/**
- * Get the value of a specific environment variable.
- * * @param key - The name of the environment variable.
- * @returns The value of the variable, or undefined if not found.
- */
-export declare function get(key: string): string | undefined;
-/**
- * Check if an environment variable exists.
- * * @param key - The name of the environment variable.
- */
-export declare function has(key: string): boolean;
-//# sourceMappingURL=env.d.ts.map

package/dist/env.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/env.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAqBH;;;;GAIG;AACH,wBAAgB,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAW/C;AAED;;;;GAIG;AACH,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAWnD;AAED;;;GAGG;AACH,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAExC"}