@socketsecurity/lib 5.28.0 → 6.0.0

package/dist/external-tools/cdxgen/types.js

@@ -0,0 +1,18 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/external-tools/from-download.d.ts

@@ -0,0 +1,162 @@
+/**
+ * @file Generic "download tier" for external-tools resolvers. The per-tool
+ *   resolvers (jre, bazel, sbt) each have local-discovery tiers — VFS, env-var
+ *   pointer, system PATH. This module adds two helpers covering the fourth
+ *   tier:
+ *
+ *   - `downloadToolArchive` — fetch the archive into the dlx cache, return the
+ *     path + computed integrity. Stops at "bytes on disk."
+ *   - `downloadAndExtractTool` — chains `downloadToolArchive` into
+ *     `archives.extractArchive`. Returns the extracted directory path plus the
+ *     integrity. Idempotent: skips extraction when the output directory already
+ *     has content. What this does NOT do:
+ *   - Pick the URL. Adoptium / Bazel-mirror / Maven URL construction is
+ *     consumer-specific; these helpers take a URL and run with it.
+ *   - Build a `Resolved*` record. The caller knows the per-tool layout (which
+ *     subdirectory holds the executable) and constructs the final `ResolvedJre`
+ *     / `ResolvedBazel` / `ResolvedSbt`. Trust-on-first-use:
+ *   - First call with no `integrity`: downloads, returns the computed
+ *     sha512-<base64> in the result. Caller writes it back to
+ *     `external-tools.json` (or wherever the pin lives).
+ *   - Subsequent calls with `integrity` set: downloads, verifies against the pin,
+ *     returns the same value. Customization:
+ *   - `downloader?` lets tests inject a fake fetch, and gives fleet consumers an
+ *     escape hatch for alternate cache backends, retry logic, or progress
+ *     reporters.
+ */
+import { downloadBinary } from '../dlx/binary-download';
+import type { ExtractOptions } from '../archives/types';
+import type { HashSpec } from '../integrity';
+/**
+ * Result of `downloadAndExtractTool`. Extends `DownloadedArchive` with the
+ * extracted directory path and an `extracted` flag indicating whether this call
+ * performed extraction (vs. reusing an existing extracted tree).
+ */
+export interface ExtractedTool extends DownloadedArchive {
+    /**
+     * Absolute path to the directory where the archive was extracted.
+     */
+    readonly extractedDir: string;
+    /**
+     * Whether this call extracted (vs. found the directory already populated).
+     * Idempotent re-runs see `extracted: false`.
+     */
+    readonly extracted: boolean;
+}
+export interface DownloadAndExtractOptions extends DownloadOptions {
+    /**
+     * Absolute path of the directory to extract into. Created if missing.
+     * Idempotent: when the directory exists and is non-empty, extraction is
+     * skipped and the existing tree is returned.
+     */
+    extractedDir: string;
+    /**
+     * Pass-through options to `archives.extractArchive` — covers `strip` for
+     * tar-style leading-component stripping plus the security-limit knobs
+     * (maxEntries, maxFileSize, maxTotalSize).
+     */
+    extractOptions?: ExtractOptions | undefined;
+}
+/**
+ * Download an archive (with integrity verification) and extract it into
+ * `extractedDir`. Idempotent: if `extractedDir` already exists and is
+ * non-empty, extraction is skipped — the helper still downloads (or cache-hits)
+ * the archive so the integrity is surfaced consistently.
+ *
+ * @example
+ *   ;```typescript
+ *   const { extractedDir, integrity } = await downloadAndExtractTool({
+ *     url: 'https://example.com/jre-21-darwin-arm64.tar.gz',
+ *     name: 'jre-21-darwin-arm64',
+ *     extractedDir: '/Users/me/.cache/socket/jre/21/darwin-arm64',
+ *     extractOptions: { strip: 1 },
+ *   })
+ *   // Caller constructs ResolvedJre from extractedDir.
+ *   ```
+ */
+export declare function downloadAndExtractTool(opts: DownloadAndExtractOptions): Promise<ExtractedTool>;
+/**
+ * SRI integrity (`sha512-<base64>`) of a downloaded archive, surfaced on the
+ * per-tool `Resolved*` shapes. Set ONLY when `source === 'download'`; the
+ * local-discovery tiers (vfs / env-pointer / path) reference bytes already on
+ * disk and don't compute a fresh hash. Use for trust-on-first-use: capture
+ * after the first download and write back to `external-tools.json` so
+ * subsequent calls verify against the pin.
+ */
+export type ResolvedToolIntegrity = string | undefined;
+/**
+ * Result of a from-download tier call. `source: 'download'` mirrors the
+ * discriminator convention used by the per-tool `Resolved*` shapes so callers
+ * can detect this branch in a `switch (source)`.
+ */
+export interface DownloadedArchive {
+    /**
+     * Absolute path to the cached archive file on disk.
+     */
+    readonly archivePath: string;
+    /**
+     * Whether this call actually fetched (vs. cache hit).
+     */
+    readonly downloaded: boolean;
+    /**
+     * SRI integrity (`sha512-<base64>`) of the cached archive. Returned on every
+     * call — pin this in `external-tools.json` after first download.
+     */
+    readonly integrity: string;
+    /**
+     * Discriminator — always `'download'` for this tier.
+     */
+    readonly source: 'download';
+}
+/**
+ * Optional downloader injection. Default: `dlx/binary-download.downloadBinary`.
+ * Replace when: - Writing unit tests that need a fake fetch (no network). -
+ * Wiring an alternate cache backend or progress reporter. - Adding
+ * fleet-specific instrumentation (metrics, retry).
+ */
+export type BinaryDownloader = typeof downloadBinary;
+export interface DownloadOptions {
+    /**
+     * Archive URL. Caller picks this per target — e.g. an Adoptium release asset
+     * for JREs, a Bazel mirror for Bazel, a Maven URL for an SBT launcher.
+     */
+    url: string;
+    /**
+     * Cache identity. The dlx layer keys the cache off `url + name`, so a stable
+     * `name` per logical artifact is required for cross-process cache reuse.
+     */
+    name: string;
+    /**
+     * Optional pinned integrity. When set, the download is verified against this
+     * hash. Omit on first use to let the helper compute and return the integrity,
+     * then pin it for future calls.
+     */
+    integrity?: HashSpec | undefined;
+    /**
+     * Inject a custom downloader. Defaults to dlx.
+     */
+    downloader?: BinaryDownloader | undefined;
+}
+/**
+ * Fetch a tool archive into the dlx cache with optional integrity verification.
+ * Returns the cached path plus the SRI integrity for trust-on-first-use
+ * pinning.
+ *
+ * @example
+ *   ;```typescript
+ *   // First call — no pin yet.
+ *   const r = await downloadToolArchive({
+ *     url: 'https://api.adoptium.net/v3/binary/...',
+ *     name: 'adoptium-jre-21-darwin-arm64',
+ *   })
+ *   // Caller writes r.integrity into external-tools.json.
+ *
+ *   // Subsequent calls — verified against the pin.
+ *   const r = await downloadToolArchive({
+ *     url,
+ *     name,
+ *     integrity: pinnedFromManifest,
+ *   })
+ *   ```
+ */
+export declare function downloadToolArchive(opts: DownloadOptions): Promise<DownloadedArchive>;

package/dist/external-tools/from-download.js

@@ -0,0 +1,72 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var from_download_exports = {};
+__export(from_download_exports, {
+  downloadAndExtractTool: () => downloadAndExtractTool,
+  downloadToolArchive: () => downloadToolArchive
+});
+module.exports = __toCommonJS(from_download_exports);
+var import_node_fs = require("node:fs");
+var import_node_fs2 = require("node:fs");
+var import_extract = require("../archives/extract");
+var import_safe = require("../fs/safe");
+var import_binary_download = require("../dlx/binary-download");
+async function downloadAndExtractTool(opts) {
+  const archive = await downloadToolArchive(opts);
+  const { extractOptions, extractedDir } = opts;
+  let extracted = false;
+  if ((0, import_node_fs.existsSync)(extractedDir)) {
+    const entries = await import_node_fs2.promises.readdir(extractedDir);
+    if (entries.length === 0) {
+      await (0, import_extract.extractArchive)(archive.archivePath, extractedDir, extractOptions);
+      extracted = true;
+    }
+  } else {
+    await (0, import_safe.safeMkdir)(extractedDir);
+    await (0, import_extract.extractArchive)(archive.archivePath, extractedDir, extractOptions);
+    extracted = true;
+  }
+  return {
+    ...archive,
+    extractedDir,
+    extracted
+  };
+}
+async function downloadToolArchive(opts) {
+  const { downloader, integrity, name, url } = opts;
+  const download = downloader ?? import_binary_download.downloadBinary;
+  const result = await download({
+    url,
+    name,
+    hash: integrity
+  });
+  return {
+    archivePath: result.binaryPath,
+    downloaded: result.downloaded,
+    integrity: result.integrity,
+    source: "download"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  downloadAndExtractTool,
+  downloadToolArchive
+});

package/dist/external-tools/janus/asset-names.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @file Upstream janus release asset-name mapping per `platform-arch`. janus
+ *   publishes per-platform tarballs under
+ *   https://github.com/divmain/janus/releases/download/v<X.Y.Z>/. At v1.22.0
+ *   only darwin-arm64 is shipped; this map will expand as upstream adds builds.
+ *   Callers receive `undefined` for unsupported platforms — surface that as an
+ *   actionable "janus is mac-arm64 only" error rather than blindly fetching a
+ *   404.
+ */
+export interface JanusAssetEntry {
+    /**
+     * Full asset filename (version-free; the helper interpolates the tag).
+     */
+    readonly asset: string;
+}
+export declare const JANUS_ASSET_MAP: Readonly<Record<string, JanusAssetEntry>>;
+export declare function getJanusAssetEntry(platformArch: string): JanusAssetEntry | undefined;
+export interface JanusDownloadOptions {
+    /**
+     * Janus release version, e.g. `'1.22.0'` (no `v` prefix; the helper prepends
+     * it for the release tag).
+     */
+    version: string;
+    /**
+     * Fleet platform-arch token — looked up in `JANUS_ASSET_MAP`. Returns
+     * `undefined` for any platform-arch janus doesn't ship a build for.
+     */
+    platformArch: string;
+}
+/**
+ * Build the GitHub release-asset download URL for an upstream janus binary.
+ * Returns `undefined` when no entry exists for the requested platform-arch.
+ *
+ * Reference: https://github.com/divmain/janus/releases.
+ */
+export declare function getJanusDownloadUrl(opts: JanusDownloadOptions): string | undefined;

package/dist/external-tools/janus/asset-names.js

@@ -0,0 +1,52 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var asset_names_exports = {};
+__export(asset_names_exports, {
+  JANUS_ASSET_MAP: () => JANUS_ASSET_MAP,
+  getJanusAssetEntry: () => getJanusAssetEntry,
+  getJanusDownloadUrl: () => getJanusDownloadUrl
+});
+module.exports = __toCommonJS(asset_names_exports);
+var import_object = require("../../primordials/object");
+const JANUS_ASSET_MAP = (0, import_object.ObjectFreeze)({
+  __proto__: null,
+  "darwin-arm64": (0, import_object.ObjectFreeze)({
+    __proto__: null,
+    asset: "janus-aarch64-apple-darwin.tar.gz"
+  })
+});
+function getJanusAssetEntry(platformArch) {
+  return JANUS_ASSET_MAP[platformArch];
+}
+function getJanusDownloadUrl(opts) {
+  const { platformArch, version } = opts;
+  const entry = JANUS_ASSET_MAP[platformArch];
+  if (!entry) {
+    return void 0;
+  }
+  return `https://github.com/divmain/janus/releases/download/v${version}/` + entry.asset;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JANUS_ASSET_MAP,
+  getJanusAssetEntry,
+  getJanusDownloadUrl
+});

package/dist/external-tools/janus/from-download.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @file `janusFromDownload()` — fetches upstream janus and returns a
+ *   `ResolvedJanus` pointing at the extracted binary. janus ships tar.gz
+ *   archives containing a bare `janus` binary at the archive root (no nested
+ *   directory). Defaults install under the shared wheelhouse dir
+ *   (`~/.socket/_wheelhouse/janus/<version>/<platform-arch>/`) rather than the
+ *   per-process dlx cache, so multiple fleet consumers reuse the same extracted
+ *   binary.
+ */
+import type { BinaryDownloader } from '../from-download';
+import type { HashSpec } from '../../integrity';
+import type { ResolvedJanus } from './types';
+export interface JanusFromDownloadOptions {
+    version: string;
+    platformArch: string;
+    integrity?: HashSpec | undefined;
+    /**
+     * Override the install directory. By default the binary lands in
+     * `<getSocketWheelhouseDir()>/janus/<version>/<platformArch>/` — a shared
+     * cross-fleet location so multiple Socket tools resolve the same binary
+     * without per-process duplication.
+     */
+    cacheDir?: string | undefined;
+    downloader?: BinaryDownloader | undefined;
+}
+export declare function janusFromDownload(opts: JanusFromDownloadOptions): Promise<ResolvedJanus | undefined>;

package/dist/external-tools/janus/from-download.js

@@ -0,0 +1,65 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var from_download_exports = {};
+__export(from_download_exports, {
+  janusFromDownload: () => janusFromDownload
+});
+module.exports = __toCommonJS(from_download_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_node_process = __toESM(require("node:process"));
+var import_socket = require("../../paths/socket");
+var import_from_download = require("../from-download");
+var import_asset_names = require("./asset-names");
+async function janusFromDownload(opts) {
+  const { cacheDir, downloader, integrity, platformArch, version } = opts;
+  const url = (0, import_asset_names.getJanusDownloadUrl)({ version, platformArch });
+  if (!url) {
+    return void 0;
+  }
+  const extractedDir = cacheDir ?? import_node_path.default.join((0, import_socket.getSocketWheelhouseDir)(), "janus", version, platformArch);
+  const archive = await (0, import_from_download.downloadAndExtractTool)({
+    url,
+    name: `janus-${version}-${platformArch}.tar.gz`,
+    integrity,
+    extractedDir,
+    downloader
+  });
+  const binary = import_node_process.default.platform === "win32" ? "janus.exe" : "janus";
+  return {
+    path: import_node_path.default.join(extractedDir, binary),
+    source: "download",
+    integrity: archive.integrity
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  janusFromDownload
+});

package/dist/external-tools/janus/from-path.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @file `janusFromPath()` — looks for `janus` on the system PATH.
+ */
+import type { ResolvedJanus } from './types';
+export declare function janusFromPath(): Promise<ResolvedJanus | undefined>;

package/dist/external-tools/janus/from-path.js

@@ -0,0 +1,40 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var from_path_exports = {};
+__export(from_path_exports, {
+  janusFromPath: () => janusFromPath
+});
+module.exports = __toCommonJS(from_path_exports);
+var import_which = require("../../bin/which");
+async function janusFromPath() {
+  const onPath = await (0, import_which.which)("janus", { nothrow: true });
+  if (typeof onPath !== "string") {
+    return void 0;
+  }
+  return {
+    path: onPath,
+    source: "path"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  janusFromPath
+});

package/dist/external-tools/janus/from-vfs.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file `janusFromVfs()` — extracts the janus binary from the smol binary's
+ *   VFS. Returns `undefined` when the binary doesn't have janus bundled.
+ */
+import type { ResolvedJanus } from './types';
+export declare const JANUS_VFS_KEY = "janus";
+export declare function janusFromVfs(): Promise<ResolvedJanus | undefined>;

package/dist/external-tools/janus/from-vfs.js

@@ -0,0 +1,47 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var from_vfs_exports = {};
+__export(from_vfs_exports, {
+  JANUS_VFS_KEY: () => JANUS_VFS_KEY,
+  janusFromVfs: () => janusFromVfs
+});
+module.exports = __toCommonJS(from_vfs_exports);
+var import_vfs = require("../../smol/vfs");
+const JANUS_VFS_KEY = "janus";
+async function janusFromVfs() {
+  const vfs = (0, import_vfs.getSmolVfs)();
+  if (!vfs) {
+    return void 0;
+  }
+  if (!vfs.has(JANUS_VFS_KEY)) {
+    return void 0;
+  }
+  const realPath = await vfs.extract(JANUS_VFS_KEY);
+  return {
+    path: realPath,
+    source: "vfs"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JANUS_VFS_KEY,
+  janusFromVfs
+});

package/dist/external-tools/janus/resolve.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @file `resolveJanus()` — janus resolution entry point. Tries each source in
+ *   order:
+ *
+ *   1. VFS — smol binary's embedded janus (if packed)
+ *   2. PATH — `janus` on the system PATH
+ *   3. download — upstream GitHub release tar.gz (only when `downloadIfMissing` is
+ *      passed) Returns `undefined` if all of the enabled sources miss —
+ *      including when `downloadIfMissing` is set but the requested
+ *      platform-arch isn't shipped by upstream janus (currently darwin-arm64
+ *      only). Memoized per option-shape.
+ */
+import type { BinaryDownloader } from '../from-download';
+import type { HashSpec } from '../../integrity';
+import type { ResolvedJanus } from './types';
+export interface ResolveJanusOptions {
+    downloadIfMissing?: {
+        version: string;
+        platformArch: string;
+        integrity?: HashSpec | undefined;
+        cacheDir?: string | undefined;
+        downloader?: BinaryDownloader | undefined;
+    } | undefined;
+}
+export declare function cacheKey(opts: ResolveJanusOptions | undefined): string;
+export declare function doResolveJanus(opts?: ResolveJanusOptions | undefined): Promise<ResolvedJanus | undefined>;
+export declare function resetJanusResolution(): void;
+export declare function resolveJanus(opts?: ResolveJanusOptions | undefined): Promise<ResolvedJanus | undefined>;

package/dist/external-tools/janus/resolve.js

@@ -0,0 +1,73 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolve_exports = {};
+__export(resolve_exports, {
+  cacheKey: () => cacheKey,
+  doResolveJanus: () => doResolveJanus,
+  resetJanusResolution: () => resetJanusResolution,
+  resolveJanus: () => resolveJanus
+});
+module.exports = __toCommonJS(resolve_exports);
+var import_from_download = require("./from-download");
+var import_from_path = require("./from-path");
+var import_from_vfs = require("./from-vfs");
+const resolutionCache = /* @__PURE__ */ new Map();
+function cacheKey(opts) {
+  if (!opts?.downloadIfMissing) {
+    return "local-only";
+  }
+  const { cacheDir, integrity, platformArch, version } = opts.downloadIfMissing;
+  const integrityKey = typeof integrity === "string" ? integrity : integrity ? `${integrity.type}:${integrity.value}` : "";
+  return `dl:${version}:${platformArch}:${integrityKey}:${cacheDir ?? ""}`;
+}
+async function doResolveJanus(opts) {
+  const fromVfs = await (0, import_from_vfs.janusFromVfs)();
+  if (fromVfs) {
+    return fromVfs;
+  }
+  const fromPath = await (0, import_from_path.janusFromPath)();
+  if (fromPath) {
+    return fromPath;
+  }
+  if (opts?.downloadIfMissing) {
+    return (0, import_from_download.janusFromDownload)(opts.downloadIfMissing);
+  }
+  return void 0;
+}
+function resetJanusResolution() {
+  resolutionCache.clear();
+}
+function resolveJanus(opts) {
+  const key = cacheKey(opts);
+  let cached = resolutionCache.get(key);
+  if (!cached) {
+    cached = doResolveJanus(opts);
+    resolutionCache.set(key, cached);
+  }
+  return cached;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cacheKey,
+  doResolveJanus,
+  resetJanusResolution,
+  resolveJanus
+});

package/dist/external-tools/janus/types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @file Shared types for janus resolution. janus is a single-binary tool from
+ *   divmain/janus. Currently distributed for macOS aarch64 only; the
+ *   platform-arch map will grow as upstream adds builds.
+ */
+import type { ResolvedToolIntegrity } from '../from-download';
+export type JanusSource = 'download' | 'path' | 'vfs';
+/**
+ * A resolved janus installation.
+ */
+export interface ResolvedJanus {
+    /**
+     * Absolute path to the `janus` executable.
+     */
+    readonly path: string;
+    /**
+     * Which resolver tier found this.
+     */
+    readonly source: JanusSource;
+    /**
+     * See {@link ResolvedToolIntegrity}.
+     */
+    readonly integrity?: ResolvedToolIntegrity;
+}