@blaxel/core 0.2.4-preview.1 → 0.2.4-preview.3

package/dist/common/internal.js

@@ -1,13 +1,135 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAlphanumericLimitedHash = getAlphanumericLimitedHash;
 exports.getGlobalUniqueHash = getGlobalUniqueHash;
-const crypto_1 = __importDefault(require("crypto"));
+// Pure JS MD5 implementation (public domain, compact)
+function md5(input) {
+    function cmn(q, a, b, x, s, t) {
+        a = (((a + q) | 0) + ((x + t) | 0)) | 0;
+        return (((a << s) | (a >>> (32 - s))) + b) | 0;
+    }
+    function ff(a, b, c, d, x, s, t) {
+        return cmn((b & c) | (~b & d), a, b, x, s, t);
+    }
+    function gg(a, b, c, d, x, s, t) {
+        return cmn((b & d) | (c & ~d), a, b, x, s, t);
+    }
+    function hh(a, b, c, d, x, s, t) {
+        return cmn(b ^ c ^ d, a, b, x, s, t);
+    }
+    function ii(a, b, c, d, x, s, t) {
+        return cmn(c ^ (b | ~d), a, b, x, s, t);
+    }
+    function md5cycle(x, k) {
+        let [a, b, c, d] = x;
+        a = ff(a, b, c, d, k[0], 7, -680876936);
+        d = ff(d, a, b, c, k[1], 12, -389564586);
+        c = ff(c, d, a, b, k[2], 17, 606105819);
+        b = ff(b, c, d, a, k[3], 22, -1044525330);
+        a = ff(a, b, c, d, k[4], 7, -176418897);
+        d = ff(d, a, b, c, k[5], 12, 1200080426);
+        c = ff(c, d, a, b, k[6], 17, -1473231341);
+        b = ff(b, c, d, a, k[7], 22, -45705983);
+        a = ff(a, b, c, d, k[8], 7, 1770035416);
+        d = ff(d, a, b, c, k[9], 12, -1958414417);
+        c = ff(c, d, a, b, k[10], 17, -42063);
+        b = ff(b, c, d, a, k[11], 22, -1990404162);
+        a = ff(a, b, c, d, k[12], 7, 1804603682);
+        d = ff(d, a, b, c, k[13], 12, -40341101);
+        c = ff(c, d, a, b, k[14], 17, -1502002290);
+        b = ff(b, c, d, a, k[15], 22, 1236535329);
+        a = gg(a, b, c, d, k[1], 5, -165796510);
+        d = gg(d, a, b, c, k[6], 9, -1069501632);
+        c = gg(c, d, a, b, k[11], 14, 643717713);
+        b = gg(b, c, d, a, k[0], 20, -373897302);
+        a = gg(a, b, c, d, k[5], 5, -701558691);
+        d = gg(d, a, b, c, k[10], 9, 38016083);
+        c = gg(c, d, a, b, k[15], 14, -660478335);
+        b = gg(b, c, d, a, k[4], 20, -405537848);
+        a = gg(a, b, c, d, k[9], 5, 568446438);
+        d = gg(d, a, b, c, k[14], 9, -1019803690);
+        c = gg(c, d, a, b, k[3], 14, -187363961);
+        b = gg(b, c, d, a, k[8], 20, 1163531501);
+        a = gg(a, b, c, d, k[13], 5, -1444681467);
+        d = gg(d, a, b, c, k[2], 9, -51403784);
+        c = gg(c, d, a, b, k[7], 14, 1735328473);
+        b = gg(b, c, d, a, k[12], 20, -1926607734);
+        a = hh(a, b, c, d, k[5], 4, -378558);
+        d = hh(d, a, b, c, k[8], 11, -2022574463);
+        c = hh(c, d, a, b, k[11], 16, 1839030562);
+        b = hh(b, c, d, a, k[14], 23, -35309556);
+        a = hh(a, b, c, d, k[1], 4, -1530992060);
+        d = hh(d, a, b, c, k[4], 11, 1272893353);
+        c = hh(c, d, a, b, k[7], 16, -155497632);
+        b = hh(b, c, d, a, k[10], 23, -1094730640);
+        a = hh(a, b, c, d, k[13], 4, 681279174);
+        d = hh(d, a, b, c, k[0], 11, -358537222);
+        c = hh(c, d, a, b, k[3], 16, -722521979);
+        b = hh(b, c, d, a, k[6], 23, 76029189);
+        a = hh(a, b, c, d, k[9], 4, -640364487);
+        d = hh(d, a, b, c, k[12], 11, -421815835);
+        c = hh(c, d, a, b, k[15], 16, 530742520);
+        b = hh(b, c, d, a, k[2], 23, -995338651);
+        a = ii(a, b, c, d, k[0], 6, -198630844);
+        d = ii(d, a, b, c, k[7], 10, 1126891415);
+        c = ii(c, d, a, b, k[14], 15, -1416354905);
+        b = ii(b, c, d, a, k[5], 21, -57434055);
+        a = ii(a, b, c, d, k[12], 6, 1700485571);
+        d = ii(d, a, b, c, k[3], 10, -1894986606);
+        c = ii(c, d, a, b, k[10], 15, -1051523);
+        b = ii(b, c, d, a, k[1], 21, -2054922799);
+        a = ii(a, b, c, d, k[8], 6, 1873313359);
+        d = ii(d, a, b, c, k[15], 10, -30611744);
+        c = ii(c, d, a, b, k[6], 15, -1560198380);
+        b = ii(b, c, d, a, k[13], 21, 1309151649);
+        a = ii(a, b, c, d, k[4], 6, -145523070);
+        d = ii(d, a, b, c, k[11], 10, -1120210379);
+        c = ii(c, d, a, b, k[2], 15, 718787259);
+        b = ii(b, c, d, a, k[9], 21, -343485551);
+        x[0] = (a + x[0]) | 0;
+        x[1] = (b + x[1]) | 0;
+        x[2] = (c + x[2]) | 0;
+        x[3] = (d + x[3]) | 0;
+    }
+    function md5blk(s) {
+        const md5blks = [];
+        for (let i = 0; i < 64; i += 4) {
+            md5blks[i >> 2] =
+                s.charCodeAt(i) +
+                    (s.charCodeAt(i + 1) << 8) +
+                    (s.charCodeAt(i + 2) << 16) +
+                    (s.charCodeAt(i + 3) << 24);
+        }
+        return md5blks;
+    }
+    function md51(s) {
+        let n = s.length, state = [1732584193, -271733879, -1732584194, 271733878], i;
+        for (i = 64; i <= n; i += 64) {
+            md5cycle(state, md5blk(s.substring(i - 64, i)));
+        }
+        s = s.substring(i - 64);
+        const tail = Array(16).fill(0);
+        for (i = 0; i < s.length; i++)
+            tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(state, tail);
+            tail.fill(0);
+        }
+        tail[14] = n * 8;
+        md5cycle(state, tail);
+        return state;
+    }
+    function rhex(n) {
+        let s = '', j = 0;
+        for (; j < 4; j++)
+            s += ('0' + ((n >> (j * 8 + 4)) & 0x0f).toString(16)).slice(-2) + ((n >> (j * 8)) & 0x0f).toString(16);
+        return s;
+    }
+    return md51(input).map(rhex).join('');
+}
 function getAlphanumericLimitedHash(input, maxSize = 48) {
-    const hash = crypto_1.default.createHash('md5').update(input).digest('hex');
+    const hash = md5(input);
     return hash.length > maxSize ? hash.substring(0, maxSize) : hash;
 }
 function getGlobalUniqueHash(workspace, type, name) {

package/dist/common/internal.test.d.ts

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

package/dist/common/internal.test.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const internal_1 = require("./internal");
+(0, vitest_1.describe)('getAlphanumericLimitedHash', () => {
+    (0, vitest_1.it)('returns correct MD5 hash for a known string', () => {
+        // MD5 of 'hello' is 5d41402abc4b2a76b9719d911017c592
+        (0, vitest_1.expect)((0, internal_1.getAlphanumericLimitedHash)('hello')).toBe('05d04104002a0bc04b02a0760b907109d0910100170c5092');
+    });
+    (0, vitest_1.it)('respects the maxSize parameter', () => {
+        const hash = (0, internal_1.getAlphanumericLimitedHash)('hello', 8);
+        (0, vitest_1.expect)(hash.length).toBe(8);
+        (0, vitest_1.expect)(hash).toBe('05d04104');
+    });
+    (0, vitest_1.it)('returns full hash if maxSize is larger than hash', () => {
+        const hash = (0, internal_1.getAlphanumericLimitedHash)('hello', 64);
+        (0, vitest_1.expect)(hash).toBe('05d04104002a0bc04b02a0760b907109d0910100170c5092');
+    });
+});
+(0, vitest_1.describe)('getGlobalUniqueHash', () => {
+    (0, vitest_1.it)('returns a hash for the combined workspace, type, and name', () => {
+        // The input string will be 'ws-type-name'
+        const expected = (0, internal_1.getAlphanumericLimitedHash)('ws-type-name', 48);
+        (0, vitest_1.expect)((0, internal_1.getGlobalUniqueHash)('ws', 'type', 'name')).toBe(expected);
+    });
+    (0, vitest_1.it)('returns a 48-character hash by default', () => {
+        const hash = (0, internal_1.getGlobalUniqueHash)('a', 'b', 'c');
+        (0, vitest_1.expect)(hash.length).toBeLessThanOrEqual(48);
+    });
+});

package/dist/index.browser.test.d.ts

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

package/dist/index.browser.test.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+// Import your SDK entry point or a function to test
+const sdk = __importStar(require("./index"));
+(0, vitest_1.describe)('SDK Browser Integration', () => {
+    (0, vitest_1.it)('should load the SDK without Node.js-only modules', () => {
+        // Example: check that SDK loads and a function exists
+        (0, vitest_1.expect)(typeof sdk).toBe('object');
+        // Add more specific tests for your SDK as needed
+    });
+});

package/dist/sandbox/filesystem.d.ts

@@ -6,6 +6,12 @@ export type CopyResponse = {
     source: string;
     destination: string;
 };
+export type WatchEvent = {
+    op: "CREATE" | "WRITE" | "REMOVE";
+    path: string;
+    name: string;
+    content?: string;
+};
 export declare class SandboxFileSystem extends SandboxAction {
     constructor(sandbox: Sandbox);
     mkdir(path: string, permissions?: string): Promise<SuccessResponse>;
@@ -14,7 +20,7 @@ export declare class SandboxFileSystem extends SandboxAction {
     rm(path: string, recursive?: boolean): Promise<SuccessResponse>;
     ls(path: string): Promise<Directory>;
     cp(source: string, destination: string): Promise<CopyResponse>;
-    watch(path: string, callback: (filePath: string, content?: string) => void | Promise<void>, options?: {
+    watch(path: string, callback: (fileEvent: WatchEvent) => void | Promise<void>, options?: {
         onError?: (error: Error) => void;
         withContent: boolean;
     }): {

package/dist/sandbox/filesystem.js

@@ -146,20 +146,29 @@ class SandboxFileSystem extends action_js_1.SandboxAction {
                     let lines = buffer.split('\n');
                     buffer = lines.pop();
                     for (const line of lines) {
-                        const filePath = line.trim();
-                        if (!filePath)
+                        const trimmed = line.trim();
+                        if (!trimmed)
                             continue;
-                        if (options?.withContent) {
+                        const fileEvent = JSON.parse(line.trim());
+                        if (options?.withContent && ["CREATE", "WRITE"].includes(fileEvent.op)) {
                             try {
+                                let filePath = "";
+                                if (fileEvent.path.endsWith("/")) {
+                                    filePath = fileEvent.path + fileEvent.name;
+                                }
+                                else {
+                                    filePath = fileEvent.path + "/" + fileEvent.name;
+                                }
                                 const content = await this.read(filePath);
-                                await callback(filePath, content);
+                                await callback({ ...fileEvent, content });
                             }
                             catch (e) {
-                                await callback(filePath, undefined);
+                                console.log(e);
+                                await callback({ ...fileEvent, content: undefined });
                             }
                         }
                         else {
-                            await callback(filePath);
+                            await callback(fileEvent);
                         }
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/core",
-  "version": "0.2.4-preview.1",
+  "version": "0.2.4-preview.3",
   "description": "Blaxel Core SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -66,13 +66,19 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.26.0",
+    "@testing-library/dom": "^9.3.0",
     "@types/ws": "^8.18.1",
+    "jsdom": "^26.1.0",
     "typescript": "^5.0.0",
-    "typescript-eslint": "^8.31.1"
+    "typescript-eslint": "^8.31.1",
+    "vite": "^5.2.0",
+    "vitest": "^1.5.0"
   },
   "scripts": {
     "lint": "eslint src/",
     "dev": "tsc --watch",
-    "build": "tsc"
+    "build": "tsc",
+    "test": "vitest --run",
+    "test:watch": "vitest --watch"
   }
 }