crossbind 2.0.0-beta.62 → 2.0.0-beta.64

package/src/utils/wasiHttp.js

@@ -0,0 +1,50 @@
+// The runtime of an http build: crossbind's wasi:http/handler export, which calls the app's
+// crossbind::http::handle, and the bindings wit-bindgen generated for it (assets/wasi-runtime/http/README.md).
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const RUNTIME = 'assets/wasi-runtime/http';
+// The stack of each request: wasi-libc mallocs one per concurrent request, with no guard below it.
+const STACK_SIZE = 1024 * 1024;
+const HEADER = 'include/crossbind/http.h';
+const LINKED = [
+    'handler.cpp',
+    'bindings/crossbind_http.c',
+    'bindings/crossbind_http.h',
+    'bindings/crossbind_http_component_type.o',
+    HEADER,
+];
+
+// paths.cli can lie outside the docker mount, so the files are copied into the build tree first.
+function stage(cliPath, dir, files) {
+    files.forEach((file) => {
+        fs.mkdirSync(path.dirname(`${dir}/${file}`), { recursive: true });
+        fs.copyFileSync(`${cliPath}/${RUNTIME}/${file}`, `${dir}/${file}`);
+    });
+}
+
+export const wasiHttpFiles = (cliPath) => LINKED.map((file) => `${cliPath}/${RUNTIME}/${file}`);
+
+export const wasiHttpHeader = (cliPath) => `${cliPath}/${RUNTIME}/${HEADER}`;
+
+// The include dir of a wasi source build, where the app's handler finds <crossbind/http.h>.
+export function stageWasiHttpInclude(cliPath, dir) {
+    stage(cliPath, dir, [HEADER]);
+    return `${dir}/include`;
+}
+
+// What an http link adds to a command's: the handler export, its bindings (C, hence -x c) with the world
+// they implement, the reactor model, which has no main, and a stack as large as the wasm builds'.
+export function stageWasiHttpLink(cliPath, dir) {
+    stage(cliPath, dir, LINKED);
+    return [
+        `-I${dir}/include`,
+        `-I${dir}/bindings`,
+        `${dir}/handler.cpp`,
+        '-x', 'c', `${dir}/bindings/crossbind_http.c`, '-x', 'none',
+        `${dir}/bindings/crossbind_http_component_type.o`,
+        '-mexec-model=reactor',
+        `-Wl,-z,stack-size=${STACK_SIZE}`,
+    ];
+}

package/src/utils/wasiToolchain.js

@@ -1,5 +1,7 @@
 // Toolchain surface for platform:'wasi' (wasm32-wasip3, wasi-sdk >= 34; run under `wasmtime`).
 
+import { isLocalRunner } from './selectRunner.js';
+
 export const WASI_TARGET_TRIPLE = 'wasm32-wasip3';
 // The sdk's clang still defaults to wasip1, so every compile/link carries --target explicitly.
 export const WASI_TARGET_FLAGS = [`--target=${WASI_TARGET_TRIPLE}`];
@@ -31,6 +33,7 @@ export const WASI_LINK_LIBS = [
     '-lunwind',
     '-lsetjmp',
     ...WASI_EMULATION_LIBS,
+    '-Wl,--wrap=lseek',
 ];
 
 export function wasiCFlags() {
@@ -41,7 +44,17 @@ export function wasiCxxFlags() {
     return [...WASI_TARGET_FLAGS, ...WASI_COMPILE_DEFINES, '-fwasm-exceptions', ...WASI_EH_CFLAGS];
 }
 
-// Env override first, then persistent ~/.crossbind.json; null when unset.
+// The host sdk of a RUNNER=LOCAL build: env override first, then persistent ~/.crossbind.json; null when
+// unset, and under the other runners, whose builds use the sdk in the image.
 export function resolveWasiSdkPath(system, env = process.env) {
+    if (!isLocalRunner(system, env)) return null;
     return env.CROSSBIND_WASI_SDK_PATH || system?.WASI_SDK_PATH || null;
 }
+
+// Recipes read the wasi-sdk location from the environment (lazily, in getBuildParams), so it names
+// the sdk the build uses: the host's under RUNNER=LOCAL, none (the image's) under the other runners.
+export function exportWasiSdkPath(system, env = process.env) {
+    const sdk = resolveWasiSdkPath(system, env);
+    if (sdk) env.CROSSBIND_WASI_SDK_PATH = sdk;
+    else delete env.CROSSBIND_WASI_SDK_PATH;
+}

package/src/utils/windowsToolchain.js

@@ -0,0 +1,18 @@
+// The windows image's llvm-mingw and its CMake toolchain files, one per target triple: port archives and
+// Conan packages link into the same addon, so they move together.
+const LLVM_MINGW = '/opt/llvm-mingw';
+const WINDOWS_TOOLCHAIN = '/opt/crossbind/windows';
+const WINDOWS_TRIPLES = { x64: 'x86_64-w64-mingw32', arm64: 'aarch64-w64-mingw32' };
+
+export const windowsTriple = (target) => WINDOWS_TRIPLES[target.arch];
+export const windowsToolchainFile = (target) => `${WINDOWS_TOOLCHAIN}/${windowsTriple(target)}.cmake`;
+export const windowsTool = (target, name) => `${LLVM_MINGW}/bin/${windowsTriple(target)}-${name}`;
+
+// The compilers, archive and resource tools of the target's triple, by the variables build systems read
+// them from. The image's own .pc files describe its libraries, not the target's, so pkg-config reads none.
+export const windowsBuildEnv = (target) => ({
+    ...Object.fromEntries(Object.entries({
+        CC: 'clang', CXX: 'clang++', AR: 'ar', RANLIB: 'ranlib', NM: 'nm', STRIP: 'strip', RC: 'windres', WINDRES: 'windres',
+    }).map(([variable, tool]) => [variable, windowsTool(target, tool)])),
+    PKG_CONFIG_LIBDIR: '',
+});

package/vitest.config.js

@@ -12,6 +12,17 @@ export default defineConfig({
     test: {
         include: ['test/**/*.test.js'],
         environment: 'node',
+        // A developer's own runner settings must not decide where the tested steps run, and neither must their
+        // crossbind login: no one signs in to a cloud at this address.
+        env: {
+            CROSSBIND_RUNNER: '',
+            CROSSBIND_REMOTE_URL: '',
+            CROSSBIND_REMOTE_URL_WEB: '',
+            CROSSBIND_REMOTE_URL_ANDROID: '',
+            CROSSBIND_REMOTE_URL_LINUX: '',
+            CROSSBIND_REMOTE_URL_WINDOWS: '',
+            CROSSBIND_CLOUD_URL: 'http://127.0.0.1:9',
+        },
         coverage: {
             provider: 'v8',
             reporter: ['text', 'html'],