crossbind 2.0.0-beta.69 → 2.0.0-beta.72

package/src/utils/runPackageSource.js

@@ -0,0 +1,251 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import getOsUserAndGroupId from './getOsUserAndGroupId.js';
+import makeTreeWritable from './makeTreeWritable.js';
+import pullDockerImage, { getDockerImage, getDockerContainerName, imageRoleFor } from './pullDockerImage.js';
+import { DOCKER_RUN_SECURITY_ARGS } from './dockerSecurity.js';
+import assertExecContainer from './execContainer.js';
+import { IOS_DEVELOPER_DIR, XCODE_TOOLCHAIN_BIN } from './iosToolchain.js';
+import { DARWIN_CC, DARWIN_TOOLS_BIN } from './darwinToolchain.js';
+import { HOST_BUILT_PLATFORMS } from './targets.js';
+import { remoteExecParams } from './remoteRunner.js';
+import { runnerFor } from './selectRunner.js';
+
+// Every run of a package source's tool goes through here. The config is passed in instead of read from
+// state, because state attaches the staged packages while it is still being built.
+//
+// The tool runs recipes, which are code, and can write wherever the tool keeps its settings and plugins.
+// So every run gets a fresh work directory, deleted with the run, for whatever of the tool must not
+// outlive it; only the package store does. On the host the environment is rebuilt from an allowlist, so
+// the tool's own variables, a stray CC or a remote's credentials never reach it.
+const ALLOWED_ENV = [
+    /^PATH$/,
+    /^HOME$/,
+    /^USER$/,
+    /^LOGNAME$/,
+    /^SHELL$/,
+    /^TERM$/,
+    /^TMPDIR$/,
+    /^TEMP$/,
+    /^TMP$/,
+    /^LANG$/,
+    /^LC_[A-Z_]+$/,
+    /^(HTTP|HTTPS|ALL|NO)_PROXY$/i,
+    /^SSL_CERT_(FILE|DIR)$/,
+    /^REQUESTS_CA_BUNDLE$/,
+    // A host Emscripten under RUNNER=LOCAL.
+    /^EMSDK(_NODE|_PYTHON)?$/,
+    /^EM_(CONFIG|CACHE)$/,
+    /^SYSTEMROOT$/i,
+    /^WINDIR$/i,
+    /^USERPROFILE$/i,
+    /^PROGRAMDATA$/i,
+];
+
+// What a tool can build on the host: wasm with a host Emscripten, iOS and macOS with Xcode.
+const HOST_PLATFORMS = ['wasm', 'ios', 'darwin'];
+const APPLE_PLATFORM_NAMES = { ios: 'iOS', darwin: 'macOS' };
+// Where a container sees sourceRoot(): an exec container mounts all of it here, a run container only
+// the store and its own work directory, at the same places.
+export const containerRootOf = (name) => `/var/cache/crossbind/${name}`;
+// A recipe's build log is the whole compiler output of a library.
+const MAX_BUFFER = 256 * 1024 * 1024;
+const SPAWN_OPTIONS = { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8', maxBuffer: MAX_BUFFER };
+
+export function sourceRunner(config, target) {
+    const { runner } = runnerFor(imageRoleFor(target), config.system);
+    // Xcode runs on the Mac alone, so iOS and macOS packages build there whatever runner the rest use.
+    return HOST_BUILT_PLATFORMS.includes(target?.platform) ? 'LOCAL' : runner;
+}
+
+// Machine-wide like the cargo cache: built packages are reused by every project, and `pnpm run clear`
+// in one project must not throw them away. Containers write to the store and a tool runs the recipes
+// it keeps there, so a tool on the host never shares a store with them.
+export function sourceRoot(name, runner = 'DOCKER_RUN') {
+    return path.join(os.homedir(), '.crossbind', runner === 'LOCAL' ? `${name}-local` : name);
+}
+
+// A directory under a source's root, with the store beside it. toolPath and storePath name a file of
+// each as the tool sees it.
+function workAt(name, runner, relative) {
+    const root = sourceRoot(name, runner);
+    const viewOf = (base) => (...segments) => (runner === 'LOCAL'
+        ? path.join(root, base, ...segments)
+        : [containerRootOf(name), base, ...segments].join('/'));
+    const toolPath = viewOf(relative);
+    return {
+        name, runner, root, store: path.join(root, 'store'), dir: path.join(root, relative), toolDir: toolPath(), toolPath, storePath: viewOf('store'),
+    };
+}
+
+// The directory one run reads its inputs from and writes its outputs to.
+export function createSourceWork(name, runner) {
+    const root = sourceRoot(name, runner);
+    fs.mkdirSync(path.join(root, 'store'), { recursive: true });
+    fs.mkdirSync(path.join(root, 'work'), { recursive: true });
+    return workAt(name, runner, `work/${path.basename(fs.mkdtempSync(path.join(root, 'work', 'run-')))}`);
+}
+
+// Where a source asks the tool of the host what it is, outside any run. Only named where an image says what runs:
+// nothing is asked there, and a build that finds every target staged touches nothing of the home.
+export function createSourceProbe(name, runner) {
+    if (runner === 'LOCAL') fs.mkdirSync(path.join(sourceRoot(name, runner), 'probe'), { recursive: true });
+    return workAt(name, runner, 'probe');
+}
+
+function removeTree(dir) {
+    if (!fs.existsSync(dir)) return;
+    makeTreeWritable(dir);
+    fs.rmSync(dir, { recursive: true, force: true });
+}
+
+export const removeSourceWork = (work) => removeTree(work.dir);
+
+// What runs that were killed left behind. Only while holding the install lock: no run is going then.
+export const clearSourceWork = (name, runner) => removeTree(path.join(sourceRoot(name, runner), 'work'));
+
+// A tool reports paths as it sees them. In a container that is through the mounts, which all sit under
+// the container's root, so mapping the prefix back is exact; a path anywhere else is none crossbind gave it.
+export function toHostPath(reported, work) {
+    if (work.runner === 'LOCAL') return path.resolve(reported);
+    const containerRoot = containerRootOf(work.name);
+    const clean = path.posix.normalize(reported);
+    // A backslash is a separator again once the path is joined on a Windows host.
+    if (reported.includes('\\') || !clean.startsWith(`${containerRoot}/`)) {
+        throw new Error(`crossbind: ${work.name} reported ${JSON.stringify(reported)}, outside the directories crossbind mounts for it.`);
+    }
+    return path.join(work.root, clean.slice(containerRoot.length + 1));
+}
+
+function allowedEnv() {
+    return Object.fromEntries(Object.entries(process.env).filter(([key]) => ALLOWED_ENV.some((allowed) => allowed.test(key))));
+}
+
+// The Xcode every crossbind iOS archive builds with, whichever one xcode-select points at.
+const iosEnv = () => ({ ...allowedEnv(), DEVELOPER_DIR: IOS_DEVELOPER_DIR });
+
+// A GNU ar or nm ahead of Apple's on a Mac's PATH (Homebrew's binutils) writes archives Apple's linker
+// cannot read, and recipes, the build tools they build and Meson all take these tools by name. So the
+// run gets links to Xcode's first on its PATH; for macOS to the ones xcode-select picks, as the macOS
+// ports are built with.
+const APPLE_TOOLS = {
+    ar: 'ar', as: 'as', nm: 'llvm-nm', ranlib: 'ranlib', strip: 'strip',
+};
+const appleToolOf = (target, name) => (target.platform === 'darwin'
+    ? path.join(DARWIN_TOOLS_BIN, name)
+    : path.join(XCODE_TOOLCHAIN_BIN, APPLE_TOOLS[name]));
+
+function withAppleTools(work, env, target) {
+    if (process.platform !== 'darwin') return env;
+    const dir = path.join(work.dir, 'apple-tools');
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir);
+        Object.keys(APPLE_TOOLS).forEach((name) => fs.symlinkSync(appleToolOf(target, name), path.join(dir, name)));
+    }
+    return { ...env, PATH: [dir, env.PATH].filter(Boolean).join(path.delimiter) };
+}
+
+const toolVersions = new Map();
+// The first line a tool prints for --version, asked once.
+function toolVersion(command, env = allowedEnv()) {
+    const key = command.join(' ');
+    if (!toolVersions.has(key)) {
+        const [program, ...args] = command;
+        const result = spawnSync(program, [...args, '--version'], { encoding: 'utf8', env });
+        toolVersions.set(key, `${result.stdout ?? ''}`.split('\n')[0].trim());
+    }
+    return toolVersions.get(key);
+}
+
+// The compiler a tool on the host builds with; for a container the image digest says the same.
+export function localCompilerIdentity(target) {
+    if (target?.platform === 'ios') return toolVersion(['xcrun', 'clang'], iosEnv());
+    if (target?.platform === 'darwin') return toolVersion([DARWIN_CC]);
+    return toolVersion(['emcc']);
+}
+
+// What a tool on the host cannot build: the targets an image's toolchain builds, and Xcode's off a Mac.
+export function assertRunsOnHost(name, target) {
+    if (!HOST_PLATFORMS.includes(target.platform)) {
+        throw new Error(`crossbind: ${name} packages for ${target.platform} build in the ${imageRoleFor(target)} image, which RUNNER=LOCAL does not use.`);
+    }
+    if (HOST_BUILT_PLATFORMS.includes(target.platform) && process.platform !== 'darwin') {
+        throw new Error(`crossbind: ${name} packages for ${APPLE_PLATFORM_NAMES[target.platform]} build with Xcode, on a Mac.`);
+    }
+}
+
+// Of a store, a remote runner sends back the folders its source says never change once written, and nothing else.
+export function assertRunsRemotely({ name, packageSource }) {
+    if (packageSource.storeUnits.length > 0) return;
+    throw new Error(`crossbind: ${name} names no storeUnits, so a remote runner would send none of its packages back: name the folders of its store that never change once written, as 'p/*/p', or build with another RUNNER.`);
+}
+
+// A tool of the host asked what it is, in a source's probe directory: no target's tools are on its PATH.
+export function runProbe([program, ...args], { work, env = {} }) {
+    return spawnSync(program, args, { ...SPAWN_OPTIONS, cwd: work.dir, env: { ...allowedEnv(), ...env } });
+}
+
+export default function runPackageSource(command, {
+    source, config, target, work, env = {},
+}) {
+    const [program, ...args] = command;
+    const role = imageRoleFor(target);
+    if (work.runner === 'LOCAL') {
+        const hostEnv = target.platform === 'ios' ? iosEnv() : allowedEnv();
+        return spawnSync(program, args, { ...SPAWN_OPTIONS, cwd: work.dir, env: withAppleTools(work, { ...hostEnv, ...env }, target) });
+    }
+
+    // Google ships the linux NDK for x86_64 only.
+    const platform = target.platform === 'android' ? 'linux/amd64' : undefined;
+    if (work.runner === 'REMOTE') {
+        return spawnSync(...remoteExecParams({
+            remote: runnerFor(role, config.system).remote,
+            role,
+            image: getDockerImage(role, platform),
+            mounts: [
+                // Of the store, only the folders the source names come back: they never change once written.
+                { host: work.store, container: work.storePath(), inputRoots: [], outputRoots: source.packageSource.storeUnits },
+                { host: work.dir, container: work.toolDir, inputRoots: ['.'], outputRoots: ['.'] },
+            ],
+            cwd: work.toolDir,
+            argv: command,
+            env,
+        }, SPAWN_OPTIONS));
+    }
+
+    const containerRoot = containerRootOf(source.name);
+    const envArgs = Object.entries(env).flatMap(([key, value]) => ['-e', `${key}=${value}`]);
+    let runnerArgs;
+    if (work.runner === 'DOCKER_EXEC') {
+        const name = getDockerContainerName(config.paths.base, role);
+        assertExecContainer({
+            name,
+            mounts: [[containerRoot, work.root]],
+            workdir: work.toolDir,
+            hint: `Recreate it with \`crossbind docker stop ${role}\`, \`crossbind docker delete ${role}\` and \`crossbind docker create ${role}\`, which mount ${work.root} at ${containerRoot}.`,
+            mountNote: `It predates the ${source.name} mount.`,
+        });
+        runnerArgs = ['exec', ...envArgs, '--user', getOsUserAndGroupId(), '--workdir', work.toolDir, name];
+    } else {
+        pullDockerImage(role, platform);
+        runnerArgs = [
+            'run',
+            '--rm',
+            ...(platform ? ['--platform', platform] : []),
+            ...DOCKER_RUN_SECURITY_ARGS,
+            '-v',
+            `${work.store}:${work.storePath()}`,
+            '-v',
+            `${work.dir}:${work.toolDir}`,
+            ...envArgs,
+            '--user',
+            getOsUserAndGroupId(),
+            '--workdir',
+            work.toolDir,
+            getDockerImage(role, platform),
+        ];
+    }
+    return spawnSync('docker', [...runnerArgs, ...command], SPAWN_OPTIONS);
+}

package/src/utils/rustBridgeGen.js

@@ -267,7 +267,7 @@ export function createRustBridgeCrate({ rsFile, cacheDir, projectPath, vectors =
         '',
         '[dependencies]',
         `embind-rs = { path = "${relPath(dir, resolveEmbindRsDir())}" }`,
-        // The app config's top-level cargoDependencies, so an app-local surface can use
+        // The app config's packages.cargo, so an app-local surface can use
         // upstream crates directly (values: a version string, or a verbatim `{ ... }` spec).
         ...Object.entries(cargoDependencies).map(([name, spec]) => (
             String(spec).trim().startsWith('{') ? `${name} = ${spec}` : `${name} = "${spec}"`
@@ -295,7 +295,7 @@ export function createRustBridgeCrate({ rsFile, cacheDir, projectPath, vectors =
     return { bridgeDir: dir, crateName: `${stem}_crossbind_app`, model };
 }
 
-// Direct CRATE import (`import { X } from 'cargo:uuid'` with top-level `cargoDependencies`
+// Direct CRATE import (`import { X } from 'cargo:uuid'` with `packages.cargo`
 // declaring `uuid`, or `cargo:<crate>/<module>` for one public module): no surface file and no
 // package - the bridge is generated from the upstream crate's OWN multi-file source. cargo
 // metadata (which fetches on first run) locates the source and the resolved feature set; the
@@ -608,7 +608,7 @@ function findModule(lib, modulePath, enabled, srcDir) {
             : undefined;
         file = decl && modFile(file, name);
         if (!file) {
-            throw new Error(`crossbind: rust bridge: module '${where}' not found in ${srcDir} - a module behind a cargo feature needs that feature in cargoDependencies, and inline mod { } blocks are not read`);
+            throw new Error(`crossbind: rust bridge: module '${where}' not found in ${srcDir} - a module behind a cargo feature needs that feature in packages.cargo, and inline mod { } blocks are not read`);
         }
         if (!decl.isPub) throw new Error(`crossbind: rust bridge: module '${where}' in ${srcDir} is private to the crate`);
     }

package/src/utils/targetToolchain.js

@@ -0,0 +1,77 @@
+import { WASM_EXCEPTION_FLAGS, targetArchiveFlags } from './archiveFlags.js';
+import { ANDROID_NDK, ANDROID_API_LEVEL } from './androidToolchain.js';
+import { IOS_DEPLOYMENT_TARGET } from './iosToolchain.js';
+import {
+    LINUX_ARCHIVE_FLAGS, linuxBuildEnv, linuxTool, linuxToolchainFile, linuxTriple,
+} from './linuxToolchain.js';
+import {
+    DARWIN_CC, DARWIN_CXX, DARWIN_DEPLOYMENT_TARGET, DARWIN_HOST_PACKAGE_PREFIXES,
+} from './darwinToolchain.js';
+import {
+    windowsBuildEnv, windowsTool, windowsToolchainFile, windowsTriple,
+} from './windowsToolchain.js';
+
+// What crossbind builds a target's own archives with, as plain data: a package source builds its packages to match,
+// since they link into the same module.
+const CPP_STANDARD = '20';
+const NDK_BIN = `${ANDROID_NDK}/toolchains/llvm/prebuilt/linux-x86_64/bin`;
+const LINUX_LIBCS = { linux: 'glibc', linuxmusl: 'musl' };
+
+const linux = (target) => ({
+    flags: LINUX_ARCHIVE_FLAGS,
+    compilers: { c: linuxTool(target, 'clang'), cpp: linuxTool(target, 'clang++') },
+    env: linuxBuildEnv(target),
+    cmakeToolchainFile: linuxToolchainFile(target),
+    triple: linuxTriple(target),
+    libc: LINUX_LIBCS[target.platform],
+});
+
+const PLATFORMS = {
+    wasm: () => ({
+        flags: WASM_EXCEPTION_FLAGS,
+        compilers: { c: 'emcc', cpp: 'em++' },
+        env: {
+            CC: 'emcc', CXX: 'em++', AR: 'emar', NM: 'emnm', RANLIB: 'emranlib', STRIP: 'emstrip',
+        },
+    }),
+    android: () => ({
+        compilers: { c: `${NDK_BIN}/clang`, cpp: `${NDK_BIN}/clang++` },
+        ndk: ANDROID_NDK,
+        apiLevel: ANDROID_API_LEVEL,
+    }),
+    // No compilers: Xcode's own build it, which xcrun finds for the SDK the arch names.
+    ios: () => ({ deploymentTarget: IOS_DEPLOYMENT_TARGET }),
+    linux,
+    linuxmusl: linux,
+    darwin: () => ({
+        compilers: { c: DARWIN_CC, cpp: DARWIN_CXX },
+        env: { PKG_CONFIG_LIBDIR: '' },
+        deploymentTarget: DARWIN_DEPLOYMENT_TARGET,
+        ignoredPrefixes: [...DARWIN_HOST_PACKAGE_PREFIXES],
+    }),
+    win32: (target) => ({
+        compilers: {
+            c: windowsTool(target, 'clang'), cpp: windowsTool(target, 'clang++'), rc: windowsTool(target, 'windres'),
+        },
+        env: windowsBuildEnv(target),
+        cmakeToolchainFile: windowsToolchainFile(target),
+        triple: windowsTriple(target),
+    }),
+};
+
+export const TOOLCHAIN_PLATFORMS = Object.keys(PLATFORMS);
+
+// Null for a platform package sources build nothing for yet.
+export function targetToolchain(target) {
+    const own = PLATFORMS[target.platform]?.(target);
+    if (!own) return null;
+    return {
+        platform: target.platform,
+        arch: target.arch,
+        runtime: target.runtime,
+        cppStandard: CPP_STANDARD,
+        env: {},
+        ...own,
+        flags: [...(own.flags ?? []), ...targetArchiveFlags(target)],
+    };
+}

package/src/state/refreshConanDependencies.js

@@ -1,17 +0,0 @@
-import attachConanDependencies from './attachConanDependencies.js';
-import { conanStageDir } from '../utils/conanImport.js';
-import { conanManifestsStamp } from '../utils/conanStage.js';
-
-const attachedFrom = new WeakMap();
-
-// Attaches what a build staged since this config last attached: a process that loaded state before
-// the build, such as a Metro server, would otherwise bind headers without the packages. Says whether
-// it attached again.
-export default function refreshConanDependencies(config) {
-    if (Object.keys(config.conanDependencies ?? {}).length === 0) return false;
-    const stamp = conanManifestsStamp(conanStageDir(config.paths.cache));
-    if (attachedFrom.get(config) === stamp) return false;
-    attachedFrom.set(config, stamp);
-    attachConanDependencies(config);
-    return true;
-}

package/src/utils/conanDependencies.js

@@ -1,66 +0,0 @@
-import { CONAN_NAME } from './conanImport.js';
-import { getContentHash } from './hash.js';
-
-// A plain version or a Conan range; a user, channel or recipe revision belongs in conan.lock instead.
-export const CONAN_VERSION = /^[A-Za-z0-9_][A-Za-z0-9_.+-]*$/;
-const VERSION_RANGE = /^\[[^\]\n]+\]$/;
-const OPTION_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const OPTION_VALUE_TYPES = ['string', 'number', 'boolean'];
-
-export function normalizeConanDependencies(raw) {
-    if (raw === undefined) return {};
-    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
-        throw new Error('crossbind: "conanDependencies" must be an object such as { zlib: \'1.3.1\' }.');
-    }
-    return Object.fromEntries(Object.entries(raw).map(([name, spec]) => [name, normalizeSpec(name, spec)]));
-}
-
-function normalizeSpec(name, spec) {
-    if (!CONAN_NAME.test(name)) {
-        throw new Error(`crossbind: conanDependencies key '${name}' is not a Conan package name (lower-case letters, digits and _ + . -).`);
-    }
-    const { version, options = {} } = typeof spec === 'string' ? { version: spec } : (spec ?? {});
-    if (typeof version !== 'string' || !(CONAN_VERSION.test(version) || VERSION_RANGE.test(version))) {
-        throw new Error(`crossbind: conanDependencies.${name} needs a version such as '1.3.1' or a range such as '[>=1.3 <2]' (got ${JSON.stringify(version)}).`);
-    }
-    if (options === null || typeof options !== 'object' || Array.isArray(options)) {
-        throw new Error(`crossbind: conanDependencies.${name}.options must be an object such as { enable_fts5: true }.`);
-    }
-    Object.entries(options).forEach(([key, value]) => {
-        if (key === 'shared') {
-            throw new Error(`crossbind: conanDependencies.${name}.options.shared - crossbind links Conan packages statically into the module and sets shared=False itself.`);
-        }
-        if (!OPTION_NAME.test(key)) {
-            throw new Error(`crossbind: conanDependencies.${name}.options - '${key}' is not an option name.`);
-        }
-        if (!OPTION_VALUE_TYPES.includes(typeof value)) {
-            throw new Error(`crossbind: conanDependencies.${name}.options.${key} must be a string, number or boolean.`);
-        }
-    });
-    return { version, options: { ...options } };
-}
-
-// What staged packages were installed for; a change to conanDependencies makes them stale.
-export const conanDependenciesKey = (dependencies) => getContentHash(JSON.stringify(dependencies));
-
-// What an app's headers and sources see of its Conan packages: the packages are staged after a header
-// may already be bound, and restaged in place when one moves to another version. Null without any.
-export function conanInputsOf(config) {
-    if (Object.keys(config.conanDependencies ?? {}).length === 0) return null;
-    return {
-        dependencies: config.conanDependencies,
-        refs: config.allDependencies.filter((d) => d.general.conan).map((d) => d.general.conan.ref),
-    };
-}
-
-export const conanRequires = (dependencies) => Object.entries(dependencies).map(([name, { version }]) => `${name}/${version}`);
-
-function optionValue(value) {
-    if (value === true) return 'True';
-    if (value === false) return 'False';
-    return String(value);
-}
-
-export const conanOptionArgs = (dependencies) => Object.entries(dependencies).flatMap(([name, { options }]) => (
-    Object.entries(options).flatMap(([key, value]) => ['-o:h', `${name}/*:${key}=${optionValue(value)}`])
-));

package/src/utils/conanImport.js

@@ -1,58 +0,0 @@
-import fs from 'node:fs';
-
-export const CONAN_PREFIX = 'conan:';
-// Conan 2 refuses upper-case package names.
-export const CONAN_NAME = /^[a-z0-9_][a-z0-9_+.-]*$/;
-// No leading dot, so neither '.' nor '..' can climb out of the include directory.
-const HEADER_SEGMENT = /^[A-Za-z0-9_+-][A-Za-z0-9_.+-]*$/;
-
-export const conanStageDir = (cacheDir) => `${cacheDir}/conan`;
-// Apart from the stage's own files, so no package name can land on one of them.
-export const conanPackageDir = (stageDir, name) => `${stageDir}/packages/${name}`;
-
-export function parseConanImport(source, headerExtensions) {
-    const [name, ...headerPath] = source.slice(CONAN_PREFIX.length).split('/');
-    if (!CONAN_NAME.test(name)) {
-        throw new Error(`crossbind: '${source}' - '${name}' is not a Conan package name; write conan:<package>/<header>, such as conan:zlib/zlib.h.`);
-    }
-    if (headerPath.length === 0) {
-        throw new Error(`crossbind: '${source}' names no header - import one of the package's headers as conan:${name}/<header>.`);
-    }
-    const bad = headerPath.find((segment) => !HEADER_SEGMENT.test(segment));
-    if (bad !== undefined) {
-        throw new Error(`crossbind: '${source}' - '${bad}' is not a header path segment.`);
-    }
-    const header = headerPath.join('/');
-    const extension = header.includes('.') ? header.split('.').at(-1) : '';
-    if (!headerExtensions.includes(extension)) {
-        throw new Error(`crossbind: '${source}' - a conan: import names a header (${headerExtensions.map((e) => `.${e}`).join(', ')}).`);
-    }
-    return { name, header };
-}
-
-// The inverse of resolveConanHeader, for the editor types of a staged header.
-export function conanImportOfHeader(file, cacheDir) {
-    const prefix = conanPackageDir(conanStageDir(cacheDir), '');
-    if (!file.startsWith(prefix)) return null;
-    const match = file.slice(prefix.length).match(/^([^/]+)\/dist\/prebuilt\/[^/]+\/include\/(.+)$/);
-    // Both end up in the module name of the generated types.
-    if (!match || !CONAN_NAME.test(match[1]) || !match[2].split('/').every((segment) => HEADER_SEGMENT.test(segment))) return null;
-    return { name: match[1], header: match[2] };
-}
-
-// Only declared packages are importable, as with cargo:; a package pulled in by another links but stays hidden.
-export function resolveConanHeader(config, source, target) {
-    const { name, header } = parseConanImport(source, config.ext.header);
-    if (!Object.hasOwn(config.conanDependencies ?? {}, name)) {
-        throw new Error(`crossbind: '${source}' is not declared - add '${name}' to conanDependencies in crossbind.config.`);
-    }
-    const dependency = config.allDependencies.find((d) => d.general.conan?.name === name);
-    if (!dependency) {
-        throw new Error(`crossbind: '${source}' - ${name} is declared in conanDependencies but not installed; crossbind installs Conan packages when a build starts.`);
-    }
-    const tried = [...new Set([target.releasePath, target.path].filter(Boolean))]
-        .map((targetPath) => `${dependency.paths.output}/prebuilt/${targetPath}/include/${header}`);
-    const found = tried.find((file) => fs.existsSync(file));
-    if (found) return found;
-    throw new Error(`crossbind: '${source}' - ${name} has no ${header}. Tried:\n${tried.map((file) => `  - ${file}`).join('\n')}`);
-}

package/src/utils/conanInstall.js

@@ -1,154 +0,0 @@
-import fs from 'node:fs';
-import upath from 'upath';
-import withDirLock from './dirLock.js';
-import logger from './logger.js';
-import loadJson from './loadJson.js';
-import writeIfChanged from './writeIfChanged.js';
-import { getContentHash } from './hash.js';
-import { getDockerImage, imageRoleFor } from './pullDockerImage.js';
-import runConan, {
-    clearConanWork, conanRoot, conanRunner, createConanWork, localToolchainIdentity, removeConanWork, toHostPath,
-} from './runConan.js';
-import { hostProfile, settingsUser, BUILD_PROFILE } from './conanProfile.js';
-import { conanRequires, conanOptionArgs, conanDependenciesKey } from './conanDependencies.js';
-import {
-    conanPackagesOf, stageConanPackage, writeConanManifest, readConanManifest, isControlCharacter,
-} from './conanStage.js';
-import { conanStageDir } from './conanImport.js';
-
-// Bumped when the stage changes shape, so a stage an older crossbind made is made again.
-const CONAN_STAGE_FORMAT = 4;
-// Enough of a failed build's log to reach the error conan ends it with.
-const LOG_TAIL_LINES = 60;
-
-const lockFileOf = (config) => upath.join(config.paths.project, 'conan.lock');
-const stampFileOf = (stageDir, target) => upath.join(stageDir, 'stamps', `${target.path}.json`);
-const logFileOf = (stageDir, target) => upath.join(stageDir, 'logs', `${target.path}.log`);
-const printable = (text) => [...text].filter((char) => char === '\n' || char === '\t' || !isControlCharacter(char)).join('');
-
-// What a staged target was made from. The toolchain is the image, or the host's compiler and conan where
-// conan runs on the host (RUNNER=LOCAL, and iOS always): the profile asks that compiler for its version,
-// so a new one is a new package id and must restage.
-function stampKey(config, target) {
-    const lock = lockFileOf(config);
-    return getContentHash(JSON.stringify({
-        format: CONAN_STAGE_FORMAT,
-        dependencies: config.conanDependencies,
-        host: hostProfile(target),
-        build: BUILD_PROFILE,
-        toolchain: conanRunner(config, target) === 'LOCAL' ? localToolchainIdentity(target) : getDockerImage(imageRoleFor(target)),
-        lock: fs.existsSync(lock) ? fs.readFileSync(lock, 'utf8') : null,
-    }));
-}
-
-// The target's manifest names the dependencies it was staged for.
-const isStaged = (config, stageDir, target) => loadJson(stampFileOf(stageDir, target))?.key === stampKey(config, target)
-    && readConanManifest(stageDir, conanDependenciesKey(config.conanDependencies), target.path) !== null;
-
-function conanFailure(target, result, logFile) {
-    if (result.error && result.error.code !== 'ENOBUFS') {
-        return new Error(`crossbind: could not run conan for ${target.path} (${result.error.message}).`);
-    }
-    let ending = `failed (exit code ${result.status})`;
-    if (result.error) ending = 'was stopped: it printed more than crossbind reads';
-    else if (result.signal) ending = `was stopped by ${result.signal}`;
-    const tail = printable(`${result.stderr ?? ''}`).trim().split('\n').slice(-LOG_TAIL_LINES).join('\n');
-    return new Error(`crossbind: conan install for ${target.path} ${ending}. Its whole log is in ${logFile}.\n${tail}`);
-}
-
-// The parsed file, or null. The parse error is left out: it quotes the text, which recipes can write.
-function readJson(file) {
-    try {
-        return JSON.parse(fs.readFileSync(file, 'utf8'));
-    } catch {
-        return null;
-    }
-}
-
-// The lockfile comes back from where the recipes ran, so only a lockfile goes into the project.
-function lockfileText(file) {
-    const lock = readJson(file);
-    if (typeof lock?.version !== 'string') {
-        throw new Error('crossbind: conan wrote no lockfile crossbind can read, so conan.lock is left as it was.');
-    }
-    return `${JSON.stringify(lock, null, 4)}\n`;
-}
-
-function installTarget(config, stageDir, target) {
-    const dependencies = config.conanDependencies;
-    const lock = lockFileOf(config);
-    const hasLock = fs.existsSync(lock);
-    const stampFile = stampFileOf(stageDir, target);
-    const logFile = logFileOf(stageDir, target);
-    // A restage that stops halfway must not pass for a finished one.
-    fs.rmSync(stampFile, { force: true });
-    const work = createConanWork(conanRunner(config, target));
-    const label = `conan ${target.path}`;
-    logger.startTask(label);
-    try {
-        fs.writeFileSync(upath.join(work.dir, 'host.profile'), hostProfile(target));
-        fs.writeFileSync(upath.join(work.dir, 'build.profile'), BUILD_PROFILE);
-        const settings = settingsUser(target);
-        if (settings) fs.writeFileSync(upath.join(work.dir, 'home', 'settings_user.yml'), settings);
-        if (hasLock) fs.copyFileSync(lock, upath.join(work.dir, 'input.lock'));
-        const result = runConan([
-            'install',
-            ...conanRequires(dependencies).flatMap((reference) => ['--requires', reference]),
-            ...conanOptionArgs(dependencies),
-            '-pr:h', work.conanPath('host.profile'),
-            '-pr:b', work.conanPath('build.profile'),
-            '--output-folder', work.conanPath('output'),
-            '--build=missing',
-            '--format=json',
-            // A file, since a build tool writing to stdout would end up inside the JSON.
-            '--out-file', work.conanPath('graph.json'),
-            // Unless told which lockfile to use, conan takes any conan.lock in its working directory.
-            ...(hasLock ? ['--lockfile', work.conanPath('input.lock'), '--lockfile-partial'] : ['--lockfile=']),
-            '--lockfile-out', work.conanPath('resolution.lock'),
-        ], { config, target, work });
-        writeIfChanged(logFile, `${result.stderr ?? ''}`);
-        if (result.error || result.status !== 0) throw conanFailure(target, result, logFile);
-
-        const graph = readJson(upath.join(work.dir, 'graph.json'))?.graph;
-        if (!graph) throw new Error(`crossbind: conan install wrote no graph crossbind can read. Its log is in ${logFile}.`);
-        const packages = conanPackagesOf(graph);
-        const distCmake = fs.readFileSync(upath.join(config.paths.cli, 'assets', 'cmake', 'dist.cmake'), 'utf8');
-        packages.forEach((pkg) => stageConanPackage(pkg, {
-            stageDir, targetPath: target.path, toHost: (reported) => toHostPath(reported, work), store: work.store, distCmake,
-        }));
-        writeConanManifest(stageDir, target.path, {
-            key: conanDependenciesKey(dependencies),
-            packages: packages.map(({
-                packageFolder, includedirs, libdirs, ...entry
-            }) => entry),
-        });
-        writeIfChanged(lock, lockfileText(upath.join(work.dir, 'resolution.lock')));
-        writeIfChanged(stampFile, `${JSON.stringify({ key: stampKey(config, target) })}\n`);
-        logger.doneTask(label, packages.map((pkg) => `${pkg.name} ${pkg.version}`).join(', '));
-    } finally {
-        // Not over the error that ended the run; the next install clears what is left.
-        try {
-            removeConanWork(work);
-        } catch (e) {
-            logger.info(`crossbind: could not remove ${work.dir} (${e.message}).`);
-        }
-    }
-}
-
-// Installs the declared Conan packages for every target not staged from the same inputs yet, and
-// says whether it staged any, so the caller attaches the new manifest.
-export default async function installConanPackages(config, targets) {
-    if (Object.keys(config.conanDependencies ?? {}).length === 0) return false;
-    const stageDir = conanStageDir(config.paths.cache);
-    const pending = targets.filter((target) => !isStaged(config, stageDir, target));
-    if (pending.length === 0) return false;
-    for (const runner of new Set(pending.map((target) => conanRunner(config, target)))) {
-        // A conan store takes one writer at a time, and every project on the machine shares it.
-        await withDirLock(`${conanRoot(runner)}-install.lock`, async () => {
-            clearConanWork(runner);
-            pending.filter((target) => conanRunner(config, target) === runner && !isStaged(config, stageDir, target))
-                .forEach((target) => installTarget(config, stageDir, target));
-        });
-    }
-    return true;
-}