@capsule-run/sdk 0.7.2 → 0.8.1

package/src/polyfills/fs.ts

@@ -3,6 +3,8 @@
  * Provides both Node.js fs API
  */
 
+import { getCwd } from './process.js';
+
 declare const globalThis: {
     'wasi:filesystem/types': any;
     'wasi:filesystem/preopens': any;
@@ -76,11 +78,24 @@ function normalizePath(path: string): string {
     return path;
 }
 
+/**
+ * Absolute paths pass through unchanged.
+ */
+function getEffectivePath(path: string): string {
+    if (path.startsWith('/')) return path;
+
+    const cwd = getCwd();
+    if (cwd === '.' || cwd === '') return path;
+    if (path === '.') return cwd;
+    if (path.startsWith('./')) return cwd.replace(/\/+$/, '') + '/' + path.slice(2);
+    return cwd.replace(/\/+$/, '') + '/' + path;
+}
+
 function resolvePath(path: string): { dir: Descriptor; relativePath: string } | null {
     const preopens = getPreopenedDirs();
     if (preopens.length === 0) return null;
 
-    const normalizedPath = normalizePath(path);
+    const normalizedPath = normalizePath(getEffectivePath(path));
 
     let catchAll: { dir: Descriptor; relativePath: string } | null = null;
 
@@ -296,12 +311,287 @@ export function readdir(
         .catch((err) => cb?.(err instanceof Error ? err : new Error(String(err))));
 }
 
+// ---------------------------------------------------------------------------
+// Sync implementations
+// ---------------------------------------------------------------------------
+
+function enoent(path: string): Error {
+    return Object.assign(
+        new Error(`ENOENT: no such file or directory, open '${path}'`),
+        { code: 'ENOENT' }
+    );
+}
+
+/**
+ * Read file contents synchronously.
+ */
+export function readFileSync(path: string, options?: ReadFileOptions | Encoding): string | Uint8Array {
+    const resolved = resolvePath(path);
+    if (!resolved) throw enoent(path);
+
+    try {
+        const fd = resolved.dir.openAt({ symlinkFollow: false }, resolved.relativePath, {}, { read: true });
+        const stat = fd.stat();
+        const [data] = fd.read(stat.size, BigInt(0));
+        const encoding = typeof options === 'string' ? options : options?.encoding;
+        return (encoding === 'utf8' || encoding === 'utf-8') ? new TextDecoder().decode(data) : data;
+    } catch (e) {
+        if (e instanceof Error && (e as any).code) throw e;
+        throw Object.assign(new Error(`ENOENT: no such file or directory, open '${path}'`), { code: 'ENOENT' });
+    }
+}
+
+/**
+ * Write data to a file synchronously.
+ */
+export function writeFileSync(path: string, data: string | Uint8Array, _options?: WriteFileOptions | Encoding): void {
+    const resolved = resolvePath(path);
+    if (!resolved) throw enoent(path);
+
+    const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+    try {
+        const fd = resolved.dir.openAt(
+            { symlinkFollow: false },
+            resolved.relativePath,
+            { create: true, truncate: true },
+            { write: true, mutateDirectory: true }
+        );
+        fd.write(bytes, BigInt(0));
+    } catch (e) {
+        throw new Error(`ENOENT: no such file or directory, open '${path}'`);
+    }
+}
+
+/**
+ * Append data to a file synchronously, creating it if it doesn't exist.
+ */
+export function appendFileSync(path: string, data: string | Uint8Array, _options?: WriteFileOptions | Encoding): void {
+    const resolved = resolvePath(path);
+    if (!resolved) throw enoent(path);
+
+    const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+    try {
+        const fd = resolved.dir.openAt(
+            { symlinkFollow: false },
+            resolved.relativePath,
+            { create: true },
+            { write: true, mutateDirectory: true }
+        );
+        const stat = fd.stat();
+        fd.write(bytes, stat.size);
+    } catch (e) {
+        throw new Error(`Failed to append to file '${path}': ${e}`);
+    }
+}
+
+/**
+ * Read directory contents synchronously.
+ */
+export function readdirSync(path: string, _options?: any): string[] {
+    const resolved = resolvePath(path);
+    if (!resolved) throw enoent(path);
+
+    try {
+        let targetDir = resolved.dir;
+        if (resolved.relativePath !== '.') {
+            targetDir = resolved.dir.openAt(
+                { symlinkFollow: false },
+                resolved.relativePath,
+                { directory: true },
+                { read: true }
+            );
+        }
+        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 Object.assign(new Error(`ENOENT: no such file or directory, scandir '${path}'`), { code: 'ENOENT' });
+    }
+}
+
+export interface StatResult {
+    isFile: () => boolean;
+    isDirectory: () => boolean;
+    isSymbolicLink: () => boolean;
+    size: number;
+    mtimeMs: number;
+    atimeMs: number;
+    ctimeMs: number;
+    mode: number;
+}
+
+function makeStatResult(type: 'file' | 'directory' | 'notfound', size: bigint = BigInt(0)): StatResult {
+    return {
+        isFile: () => type === 'file',
+        isDirectory: () => type === 'directory',
+        isSymbolicLink: () => false,
+        size: Number(size),
+        mtimeMs: 0,
+        atimeMs: 0,
+        ctimeMs: 0,
+        mode: type === 'directory' ? 0o40755 : 0o100644,
+    };
+}
+
+/**
+ * Get file stats synchronously.
+ */
+export function statSync(path: string): StatResult {
+    const resolved = resolvePath(path);
+    if (!resolved) throw enoent(path);
+
+    try {
+        const fd = resolved.dir.openAt({ symlinkFollow: false }, resolved.relativePath, {}, { read: true });
+        const s = fd.stat();
+        const type = s.type === 'directory' ? 'directory' : 'file';
+        return makeStatResult(type, s.size);
+    } catch (e) {
+        throw Object.assign(new Error(`ENOENT: no such file or directory, stat '${path}'`), { code: 'ENOENT' });
+    }
+}
+
+/**
+ * Get file stats synchronously (no symlink follow — same as stat in WASI 0.2).
+ */
+export function lstatSync(path: string): StatResult {
+    return statSync(path);
+}
+
+/**
+ * Create a directory synchronously.
+ */
+export function mkdirSync(path: string, options?: MkdirOptions): void {
+    if (options?.recursive) {
+        const normalized = normalizePath(path);
+        const parts = normalized.split('/').filter(Boolean);
+        for (let i = 1; i <= parts.length; i++) {
+            const partial = parts.slice(0, i).join('/');
+            const resolved = resolvePath(partial);
+            if (!resolved) continue;
+            try { resolved.dir.createDirectoryAt(resolved.relativePath); } catch { /* already exists */ }
+        }
+    } else {
+        const resolved = resolvePath(path);
+        if (!resolved) throw enoent(path);
+        try {
+            resolved.dir.createDirectoryAt(resolved.relativePath);
+        } catch (e) {
+            throw Object.assign(new Error(`EEXIST: file already exists, mkdir '${path}'`), { code: 'EEXIST' });
+        }
+    }
+}
+
+/**
+ * Remove a directory synchronously.
+ */
+export function rmdirSync(path: string, _options?: RmdirOptions): void {
+    const resolved = resolvePath(path);
+    if (!resolved) throw enoent(path);
+    try {
+        resolved.dir.removeDirectoryAt(resolved.relativePath);
+    } catch (e) {
+        throw Object.assign(new Error(`ENOENT: no such file or directory, rmdir '${path}'`), { code: 'ENOENT' });
+    }
+}
+
+/**
+ * Remove a file or directory synchronously.
+ */
+export function rmSync(path: string, options?: RmOptions): void {
+    const resolved = resolvePath(path);
+    if (!resolved) {
+        if (options?.force) return;
+        throw enoent(path);
+    }
+
+    try {
+        const fd = resolved.dir.openAt({ symlinkFollow: false }, resolved.relativePath, {}, { read: true });
+        const s = fd.stat();
+        if (s.type === 'directory') {
+            if (!options?.recursive) {
+                throw Object.assign(
+                    new Error(`EISDIR: illegal operation on a directory, rm '${path}'`),
+                    { code: 'EISDIR' }
+                );
+            }
+            resolved.dir.removeDirectoryAt(resolved.relativePath);
+        } else {
+            resolved.dir.unlinkFileAt(resolved.relativePath);
+        }
+    } catch (e) {
+        if (options?.force) return;
+        if (e instanceof Error && (e as any).code) throw e;
+        throw enoent(path);
+    }
+}
+
+/**
+ * Remove a file synchronously.
+ */
+export function unlinkSync(path: string): void {
+    const resolved = resolvePath(path);
+    if (!resolved) throw enoent(path);
+    try {
+        resolved.dir.unlinkFileAt(resolved.relativePath);
+    } catch (e) {
+        throw Object.assign(new Error(`ENOENT: no such file or directory, unlink '${path}'`), { code: 'ENOENT' });
+    }
+}
+
+/**
+ * Copy a file synchronously.
+ */
+export function copyFileSync(src: string, dest: string): void {
+    const data = readFileSync(src) as Uint8Array;
+    writeFileSync(dest, data);
+}
+
+/**
+ * Rename a file or directory synchronously.
+ */
+export function renameSync(oldPath: string, newPath: string): void {
+    try {
+        const data = readFileSync(oldPath);
+        writeFileSync(newPath, data as Uint8Array);
+        unlinkSync(oldPath);
+    } catch (e) {
+        throw Object.assign(
+            new Error(`ENOENT: no such file or directory, rename '${oldPath}' -> '${newPath}'`),
+            { code: 'ENOENT' }
+        );
+    }
+}
+
+/**
+ * Check file accessibility synchronously.
+ * Throws if the path does not exist.
+ */
+export function accessSync(path: string, _mode?: number): void {
+    const resolved = resolvePath(path);
+    if (!resolved) throw enoent(path);
+    try {
+        resolved.dir.openAt({ symlinkFollow: false }, resolved.relativePath, {}, { read: true });
+    } catch (e) {
+        throw Object.assign(new Error(`ENOENT: no such file or directory, access '${path}'`), { code: 'ENOENT' });
+    }
+}
+
 /**
- * Check if file/directory exists (sync-style, limited in WASM)
+ * Check if a path exists synchronously.
  */
-export function existsSync(_path: string): boolean {
-    console.warn('fs.existsSync: Cannot implement true sync in WASM. Use fs.access instead.');
-    return false;
+export function existsSync(path: string): boolean {
+    const resolved = resolvePath(path);
+    if (!resolved) return false;
+    try {
+        resolved.dir.openAt({ symlinkFollow: false }, resolved.relativePath, {}, { read: true });
+        return true;
+    } catch {
+        return false;
+    }
 }
 
 /**
@@ -533,15 +823,15 @@ export const promises = {
         await unlink(path);
     },
 
-    async stat(path: string): Promise<{ isFile: () => boolean; isDirectory: () => boolean }> {
+    async stat(path: string): Promise<StatResult> {
         const kind = await statPath(path);
         if (kind === 'notfound') {
-            throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
+            throw Object.assign(
+                new Error(`ENOENT: no such file or directory, stat '${path}'`),
+                { code: 'ENOENT' }
+            );
         }
-        return {
-            isFile: () => kind === 'file',
-            isDirectory: () => kind === 'directory',
-        };
+        return makeStatResult(kind);
     },
 
     async rmdir(path: string, options?: RmdirOptions): Promise<void> {
@@ -566,16 +856,31 @@ export const promises = {
 };
 
 const fs = {
+    // Async / callback
     readFile,
     writeFile,
     readdir,
-    existsSync,
     unlink,
     rmdir,
     rm,
     mkdir,
     copyFile,
     cp,
+    readFileSync,
+    writeFileSync,
+    appendFileSync,
+    readdirSync,
+    statSync,
+    lstatSync,
+    mkdirSync,
+    rmdirSync,
+    rmSync,
+    unlinkSync,
+    copyFileSync,
+    renameSync,
+    accessSync,
+    existsSync,
+    // Promises API
     promises,
 };
 

package/src/polyfills/process.ts

@@ -9,6 +9,16 @@ declare const globalThis: {
         getArguments(): string[];
         initialCwd(): string | null;
     };
+    'wasi:cli/stdin': {
+        getStdin(): {
+            blockingRead(len: bigint): [Uint8Array, boolean];
+        };
+    };
+    'wasi:cli/stdout': {
+        getStdout(): {
+            blockingWriteAndFlush(buf: Uint8Array): void;
+        };
+    };
 };
 
 /**
@@ -60,22 +70,44 @@ function getArgv(): string[] {
 }
 
 /**
- * Get current working directory from WASI
+ * Initialized from wasi:cli/environment initialCwd(), falls back to '.'.
  */
-function getCwd(): string {
-    const bindings = getEnvBindings();
-    if (!bindings || typeof bindings.initialCwd !== 'function') {
-        return '/';
-    }
-
+let _virtualCwd: string = (() => {
     try {
-        const cwd = bindings.initialCwd();
-        return cwd || '/';
-    } catch {
-        return '/';
+        const env = (globalThis as any)['wasi:cli/environment'];
+        if (env && typeof env.initialCwd === 'function') {
+            return env.initialCwd() ?? '.';
+        }
+    } catch {}
+    return '.';
+})();
+
+/**
+ * Internal setter for virtual CWD — handles relative and absolute paths.
+ */
+function setCwd(directory: string): void {
+    if (!directory) return;
+    if (directory.startsWith('/')) {
+        _virtualCwd = directory.replace(/\/+$/, '') || '/';
+    } else if (directory === '..') {
+        const parts = _virtualCwd.split('/').filter(Boolean);
+        parts.pop();
+        _virtualCwd = parts.join('/') || '.';
+    } else {
+        _virtualCwd = (_virtualCwd === '.' || _virtualCwd === '')
+            ? directory.replace(/\/+$/, '')
+            : _virtualCwd.replace(/\/+$/, '') + '/' + directory.replace(/\/+$/, '');
     }
 }
 
+/**
+ * Returns the current virtual CWD.
+ * Exported so the fs polyfill can resolve relative paths against it.
+ */
+export function getCwd(): string {
+    return _virtualCwd;
+}
+
 const process = {
     /**
      * Environment variables
@@ -92,17 +124,20 @@ const process = {
     },
 
     /**
-     * Returns the current working directory
+     * Returns the current virtual working directory.
+     * Backed by in-process state, same as CPython's WASI libc.
      */
     cwd(): string {
         return getCwd();
     },
 
     /**
-     * Change directory (not supported in WASI)
+     * Change the virtual working directory.
+     * Affects all relative path resolution in the fs polyfill.
+     * Does not perform any real syscall — mirrors CPython WASI behaviour.
      */
     chdir(directory: string): void {
-        throw new Error('process.chdir() is not supported in WASI environment');
+        setCwd(directory);
     },
 
     /**
@@ -178,24 +213,88 @@ const process = {
     },
 
     /**
-     * Standard streams (not fully implemented)
+     * Standard input — backed by wasi:cli/stdin@0.2.0.
+     * Exposes a minimal EventEmitter-compatible Readable so that
+     * MCP's StdioServerTransport can call stdin.on('data', ...).
      */
-    get stdout(): any {
+    get stdin(): any {
+        const listeners: Array<(chunk: Uint8Array | string) => void> = [];
+        let reading = false;
+
+        function startReading() {
+            if (reading) return;
+            reading = true;
+            (async () => {
+                try {
+                    const api = globalThis['wasi:cli/stdin'];
+                    if (!api) return;
+                    const stream = api.getStdin();
+                    while (true) {
+                        const [chunk, done] = stream.blockingRead(BigInt(4096));
+                        if (chunk && chunk.length > 0) {
+                            const buf = chunk;
+                            listeners.forEach(fn => fn(buf));
+                        }
+                        if (done) {
+                            endListeners.forEach(fn => fn());
+                            break;
+                        }
+                    }
+                } catch { /* stdin not available */ }
+            })();
+        }
+
+        const endListeners: Array<() => void> = [];
+
         return {
-            write: (data: string) => console.log(data),
             isTTY: false,
+            readable: true,
+            on(event: string, fn: (...args: any[]) => void) {
+                if (event === 'data') { listeners.push(fn); startReading(); }
+                if (event === 'end') { endListeners.push(fn); }
+                return this;
+            },
+            once(event: string, fn: (...args: any[]) => void) {
+                return this.on(event, fn);
+            },
+            pause() { return this; },
+            resume() { startReading(); return this; },
+            pipe(dest: any) { return dest; },
+            setEncoding(_enc: string) { return this; },
         };
     },
 
-    get stderr(): any {
+    /**
+     * Standard output — backed by wasi:cli/stdout@0.2.0.
+     */
+    get stdout(): any {
         return {
-            write: (data: string) => console.error(data),
             isTTY: false,
+            write(data: string | Uint8Array, _enc?: string, cb?: () => void): boolean {
+                try {
+                    const api = globalThis['wasi:cli/stdout'];
+                    if (api) {
+                        const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+                        api.getStdout().blockingWriteAndFlush(bytes);
+                    } else {
+                        console.log(typeof data === 'string' ? data : new TextDecoder().decode(data));
+                    }
+                } catch {
+                    console.log(typeof data === 'string' ? data : new TextDecoder().decode(data));
+                }
+                cb?.();
+                return true;
+            },
+            end(data?: string | Uint8Array, cb?: () => void): void {
+                if (data) this.write(data);
+                cb?.();
+            },
         };
     },
 
-    get stdin(): any {
+    get stderr(): any {
         return {
+            write: (data: string) => console.error(data),
             isTTY: false,
         };
     },

package/src/run.ts

@@ -8,6 +8,7 @@
 import { execFile } from 'child_process';
 import { resolve, extname } from 'path';
 import { existsSync } from 'fs';
+import { HostRequest } from './task';
 
 export interface RunnerOptions {
   file: string;
@@ -26,6 +27,8 @@ export interface RunnerResult {
     duration_ms: number;
     retries: number;
     fuel_consumed: number;
+    ram_used: number;
+    host_requests: HostRequest[];
   };
 }
 

package/src/task.ts

@@ -50,13 +50,18 @@ interface TaskExecution {
     duration_ms: number;
     retries: number;
     fuel_consumed: number;
+    ram_used: number;
+    host_requests: HostRequest[];
 }
 
-type Awaited<T> = T extends Promise<infer U> ? U : T;
+export interface HostRequest {
+  method: string;
+  url: string;
+  headers?: string[] | null;
+  body?: string | null;
+  status: number;
+}
 
-type TaskReturnType<T> = T extends Promise<infer U>
-  ? Promise<TaskResult<U>>
-  : TaskResult<T>;
 
 /**
  * Define a Capsule task with configuration.
@@ -121,10 +126,20 @@ function normalizeAllowedFile(entry: string | AllowedFile): string {
   }
 }
 
-export function task<TArgs extends any[], TReturn>(
+export function task<TArgs extends unknown[], TReturn>(
+  options: TaskOptions,
+  fn: (...args: TArgs) => Promise<TReturn>
+): (...args: TArgs) => Promise<TaskResult<TReturn>>;
+
+export function task<TArgs extends unknown[], TReturn>(
   options: TaskOptions,
   fn: (...args: TArgs) => TReturn
-): (...args: TArgs) => TaskReturnType<TReturn> {
+): (...args: TArgs) => TaskResult<TReturn>;
+
+export function task<TArgs extends unknown[], TReturn>(
+  options: TaskOptions,
+  fn: (...args: TArgs) => TReturn | Promise<TReturn>
+): (...args: TArgs) => TaskResult<TReturn> | Promise<TaskResult<TReturn>> {
   const taskName = options.name;
   let compute = options.compute?.toString().toUpperCase() ?? "MEDIUM";
   let allowedHosts = options.allowedHosts ?? [];
@@ -140,45 +155,48 @@ export function task<TArgs extends any[], TReturn>(
     envVariables: options.envVariables,
   };
 
-  const wrapper = (...args: TArgs): TaskReturnType<TReturn> => {
+  const wrapper = (...args: TArgs): TaskResult<TReturn> | Promise<TaskResult<TReturn>> => {
     if (!isWasmMode()) {
       const result = fn(...args);
 
       if (result instanceof Promise) {
         return result.then((value) => ({
           success: true,
-          result: value,
+          result: value as TReturn,
           error: null,
           execution: {
             task_name: taskName,
             duration_ms: 0,
             retries: 0,
             fuel_consumed: 0,
+            ram_used: 0,
+            host_requests: [],
           },
-        })) as TaskReturnType<TReturn>;
+        }));
       }
 
       return {
         success: true,
-        result,
+        result: result as TReturn,
         error: null,
         execution: {
           task_name: taskName,
           duration_ms: 0,
           retries: 0,
           fuel_consumed: 0,
+          ram_used: 0,
+          host_requests: [],
         },
-      } as TaskReturnType<TReturn>;
+      };
     }
 
     const resultJson = callHost(taskName, args, taskConfig);
 
     try {
-      const result: TaskResult<Awaited<TReturn>> = JSON.parse(resultJson);
-      return result as TaskReturnType<TReturn>;
+      return JSON.parse(resultJson) as TaskResult<TReturn>;
     } catch (e) {
       if (e instanceof SyntaxError) {
-        return resultJson as unknown as TaskReturnType<TReturn>;
+        return resultJson as unknown as TaskResult<TReturn>;
       }
       throw e;
     }

package/dist/polyfills/buffer.d.ts

@@ -1,8 +0,0 @@
-/**
- * Buffer polyfill for WASI environment
- * Provides Node.js-compatible Buffer class using the buffer package
- */
-import { Buffer as BufferPolyfill } from 'buffer';
-export declare const Buffer: BufferConstructor;
-export default BufferPolyfill;
-//# sourceMappingURL=buffer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"buffer.d.ts","sourceRoot":"","sources":["../../src/polyfills/buffer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,IAAI,cAAc,EAAE,MAAM,QAAQ,CAAC;AAIlD,eAAO,MAAM,MAAM,mBAAiB,CAAC;AACrC,eAAe,cAAc,CAAC"}