@socketsecurity/lib 5.28.0 → 6.0.1

package/dist/external-tools/opengrep/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, {
+  opengrepFromPath: () => opengrepFromPath
+});
+module.exports = __toCommonJS(from_path_exports);
+var import_which = require("../../bin/which");
+async function opengrepFromPath() {
+  const onPath = await (0, import_which.which)("opengrep", { 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 = {
+  opengrepFromPath
+});

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

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

package/dist/external-tools/opengrep/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, {
+  OPENGREP_VFS_KEY: () => OPENGREP_VFS_KEY,
+  opengrepFromVfs: () => opengrepFromVfs
+});
+module.exports = __toCommonJS(from_vfs_exports);
+var import_vfs = require("../../smol/vfs");
+const OPENGREP_VFS_KEY = "opengrep";
+async function opengrepFromVfs() {
+  const vfs = (0, import_vfs.getSmolVfs)();
+  if (!vfs) {
+    return void 0;
+  }
+  if (!vfs.has(OPENGREP_VFS_KEY)) {
+    return void 0;
+  }
+  const realPath = await vfs.extract(OPENGREP_VFS_KEY);
+  return {
+    path: realPath,
+    source: "vfs"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OPENGREP_VFS_KEY,
+  opengrepFromVfs
+});

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

@@ -0,0 +1,26 @@
+/**
+ * @file `resolveOpengrep()` — OpenGrep resolution entry point. Tries each
+ *   source in order:
+ *
+ *   1. VFS — smol binary's embedded OpenGrep (if packed)
+ *   2. PATH — `opengrep` on the system PATH
+ *   3. download — upstream GitHub release asset (only when `downloadIfMissing` is
+ *      passed) Returns `undefined` if all of the enabled sources miss. Memoized
+ *      per option-shape.
+ */
+import type { BinaryDownloader } from '../from-download';
+import type { HashSpec } from '../../integrity';
+import type { ResolvedOpengrep } from './types';
+export interface ResolveOpengrepOptions {
+    downloadIfMissing?: {
+        version: string;
+        platformArch: string;
+        integrity?: HashSpec | undefined;
+        cacheDir?: string | undefined;
+        downloader?: BinaryDownloader | undefined;
+    } | undefined;
+}
+export declare function cacheKey(opts: ResolveOpengrepOptions | undefined): string;
+export declare function doResolveOpengrep(opts?: ResolveOpengrepOptions | undefined): Promise<ResolvedOpengrep | undefined>;
+export declare function resetOpengrepResolution(): void;
+export declare function resolveOpengrep(opts?: ResolveOpengrepOptions | undefined): Promise<ResolvedOpengrep | undefined>;

package/dist/external-tools/opengrep/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,
+  doResolveOpengrep: () => doResolveOpengrep,
+  resetOpengrepResolution: () => resetOpengrepResolution,
+  resolveOpengrep: () => resolveOpengrep
+});
+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 doResolveOpengrep(opts) {
+  const fromVfs = await (0, import_from_vfs.opengrepFromVfs)();
+  if (fromVfs) {
+    return fromVfs;
+  }
+  const fromPath = await (0, import_from_path.opengrepFromPath)();
+  if (fromPath) {
+    return fromPath;
+  }
+  if (opts?.downloadIfMissing) {
+    return (0, import_from_download.opengrepFromDownload)(opts.downloadIfMissing);
+  }
+  return void 0;
+}
+function resetOpengrepResolution() {
+  resolutionCache.clear();
+}
+function resolveOpengrep(opts) {
+  const key = cacheKey(opts);
+  let cached = resolutionCache.get(key);
+  if (!cached) {
+    cached = doResolveOpengrep(opts);
+    resolutionCache.set(key, cached);
+  }
+  return cached;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cacheKey,
+  doResolveOpengrep,
+  resetOpengrepResolution,
+  resolveOpengrep
+});

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

@@ -0,0 +1,24 @@
+/**
+ * @file Shared types for OpenGrep resolution. OpenGrep is a semgrep fork used
+ *   by socket-basics for SAST. Ships as bare binaries on macOS/Linux (no
+ *   archive wrapper) and as a zip on Windows.
+ */
+import type { ResolvedToolIntegrity } from '../from-download';
+export type OpengrepSource = 'download' | 'path' | 'vfs';
+/**
+ * A resolved OpenGrep installation.
+ */
+export interface ResolvedOpengrep {
+    /**
+     * Absolute path to the `opengrep` executable.
+     */
+    readonly path: string;
+    /**
+     * Which resolver tier found this.
+     */
+    readonly source: OpengrepSource;
+    /**
+     * See {@link ResolvedToolIntegrity}.
+     */
+    readonly integrity?: ResolvedToolIntegrity;
+}

package/dist/external-tools/opengrep/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/sbt/asset-names.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file SBT distribution download-URL builder. SBT (Scala Build Tool) ships a
+ *   platform-agnostic launcher tarball via GitHub releases
+ *   (`sbt-<version>.tgz`). The archive contains a `bin/sbt` script and a
+ *   `bin/sbt-launch.jar` — both run on any platform with a JRE available. No
+ *   platform-arch query map needed because there's only one asset per version.
+ *   We still expose the URL builder so consumers don't encode the release path
+ *   in every callsite.
+ */
+/**
+ * Options for {@link getSbtDownloadUrl}.
+ */
+export interface SbtDownloadOptions {
+    /**
+     * SBT release version, e.g. `'1.10.7'`. Passed verbatim into the release tag.
+     */
+    version: string;
+}
+/**
+ * Build the GitHub release-asset download URL for the SBT launcher tarball.
+ * Always returns a URL — SBT has no per-platform variations.
+ *
+ * Reference: https://github.com/sbt/sbt/releases.
+ *
+ * @example
+ *   ;```typescript
+ *   const url = getSbtDownloadUrl({ version: '1.10.7' })
+ *   // → 'https://github.com/sbt/sbt/releases/download/v1.10.7/sbt-1.10.7.tgz'
+ *   ```
+ */
+export declare function getSbtDownloadUrl(opts: SbtDownloadOptions): string;

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

@@ -0,0 +1,33 @@
+"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, {
+  getSbtDownloadUrl: () => getSbtDownloadUrl
+});
+module.exports = __toCommonJS(asset_names_exports);
+function getSbtDownloadUrl(opts) {
+  const { version } = opts;
+  return `https://github.com/sbt/sbt/releases/download/v${version}/sbt-${version}.tgz`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSbtDownloadUrl
+});

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

@@ -0,0 +1,44 @@
+/**
+ * @file `sbtFromDownload()` — fetches the SBT launcher tarball, extracts it,
+ *   and returns a `ResolvedSbt` pointing at the `bin/sbt` script. SBT
+ *   distributes a single platform-agnostic tgz containing a `bin/sbt` script
+ *   plus `bin/sbt-launch.jar`. The `bin/sbt` form is directly invocable (it
+ *   shells out to `java -jar` internally), so `isJar: false` even though the
+ *   underlying machinery is a JAR. Default cache layout:
+ *   `<dlxDir>/sbt/<version>/`. Trust-on-first-use: pass `integrity` from
+ *   `external-tools.json` when available.
+ */
+import type { BinaryDownloader } from '../from-download';
+import type { HashSpec } from '../../integrity';
+import type { ResolvedSbt } from './types';
+export interface SbtFromDownloadOptions {
+    /**
+     * SBT release version, e.g. `'1.10.7'`.
+     */
+    version: string;
+    /**
+     * Optional pinned integrity from `external-tools.json`.
+     */
+    integrity?: HashSpec | undefined;
+    /**
+     * Override the cache directory. Default:
+     * `<getSocketDlxDir()>/sbt/<version>/`.
+     */
+    cacheDir?: string | undefined;
+    /**
+     * Inject a custom downloader. Forwarded to the underlying
+     * `downloadAndExtractTool`. Defaults to dlx.
+     */
+    downloader?: BinaryDownloader | undefined;
+}
+/**
+ * Resolve SBT by downloading and extracting the upstream tgz. Returns the
+ * standard `ResolvedSbt` shape with `source: 'download'`.
+ *
+ * @example
+ *   ;```typescript
+ *   const sbt = await sbtFromDownload({ version: '1.10.7' })
+ *   // → { path: '/.../bin/sbt', isJar: false, source: 'download' }
+ *   ```
+ */
+export declare function sbtFromDownload(opts: SbtFromDownloadOptions): Promise<ResolvedSbt | undefined>;

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

@@ -0,0 +1,64 @@
+"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, {
+  sbtFromDownload: () => sbtFromDownload
+});
+module.exports = __toCommonJS(from_download_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_socket = require("../../paths/socket");
+var import_from_download = require("../from-download");
+var import_asset_names = require("./asset-names");
+async function sbtFromDownload(opts) {
+  const { cacheDir, downloader, integrity, version } = opts;
+  const url = (0, import_asset_names.getSbtDownloadUrl)({ version });
+  const extractedDir = cacheDir ?? import_node_path.default.join((0, import_socket.getSocketDlxDir)(), "sbt", version);
+  const archive = await (0, import_from_download.downloadAndExtractTool)({
+    url,
+    // `.tgz` suffix is load-bearing: extractArchive auto-detects
+    // format from the cached filename's extension.
+    name: `sbt-${version}.tgz`,
+    integrity,
+    extractedDir,
+    extractOptions: { strip: 1 },
+    downloader
+  });
+  return {
+    path: import_node_path.default.join(extractedDir, "bin", "sbt"),
+    isJar: false,
+    source: "download",
+    integrity: archive.integrity
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sbtFromDownload
+});

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

@@ -0,0 +1,8 @@
+/**
+ * @file `sbtFromPath()` — looks for the `sbt` shell script on the system PATH.
+ *   Returns it as a direct-executable launcher (the script knows how to find a
+ *   JRE itself, so the caller doesn't need to resolve one). Returns `undefined`
+ *   if `sbt` isn't on PATH.
+ */
+import type { ResolvedSbt } from './types';
+export declare function sbtFromPath(): Promise<ResolvedSbt | undefined>;

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

@@ -0,0 +1,41 @@
+"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, {
+  sbtFromPath: () => sbtFromPath
+});
+module.exports = __toCommonJS(from_path_exports);
+var import_which = require("../../bin/which");
+async function sbtFromPath() {
+  const sbt = await (0, import_which.which)("sbt", { nothrow: true });
+  if (typeof sbt !== "string") {
+    return void 0;
+  }
+  return {
+    path: sbt,
+    isJar: false,
+    source: "path"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sbtFromPath
+});

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

@@ -0,0 +1,14 @@
+/**
+ * @file `sbtFromVfs()` — extracts the SBT launcher jar from the smol binary's
+ *   VFS. Uses the post-alignment `getSmolVfs()` API. The smol-btm builder packs
+ *   only the launcher (~1.5 MB); the actual SBT distribution downloads into the
+ *   user's `~/.sbt/boot/` on first run when the launcher reads
+ *   `project/build.properties`. Returns `undefined` when the binary doesn't
+ *   have SBT bundled.
+ */
+import type { ResolvedSbt } from './types';
+/**
+ * Relative VFS key for the bundled SBT launcher jar.
+ */
+export declare const SBT_VFS_KEY = "sbt-launch.jar";
+export declare function sbtFromVfs(): Promise<ResolvedSbt | undefined>;

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

@@ -0,0 +1,48 @@
+"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, {
+  SBT_VFS_KEY: () => SBT_VFS_KEY,
+  sbtFromVfs: () => sbtFromVfs
+});
+module.exports = __toCommonJS(from_vfs_exports);
+var import_vfs = require("../../smol/vfs");
+const SBT_VFS_KEY = "sbt-launch.jar";
+async function sbtFromVfs() {
+  const vfs = (0, import_vfs.getSmolVfs)();
+  if (!vfs) {
+    return void 0;
+  }
+  if (!vfs.has(SBT_VFS_KEY)) {
+    return void 0;
+  }
+  const realPath = await vfs.extract(SBT_VFS_KEY);
+  return {
+    path: realPath,
+    isJar: true,
+    source: "vfs"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SBT_VFS_KEY,
+  sbtFromVfs
+});

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

@@ -0,0 +1,31 @@
+/**
+ * @file `resolveSbt()` — SBT resolution entry point. Tries each source in
+ *   order:
+ *
+ *   1. VFS — smol binary's embedded `sbt-launch.jar` (if packed)
+ *   2. PATH — `sbt` script on the system PATH
+ *   3. download — upstream GitHub release tgz (only when `downloadIfMissing` is
+ *      passed) VFS-sourced SBT is a `.jar` that must be invoked as `java -jar
+ *      <path>` using the JRE resolved separately via `resolveJre()`. PATH- and
+ *      download-sourced SBT is the `sbt` script, which finds its own JRE.
+ *      Memoized per option-shape.
+ */
+import type { BinaryDownloader } from '../from-download';
+import type { HashSpec } from '../../integrity';
+import type { ResolvedSbt } from './types';
+export interface ResolveSbtOptions {
+    /**
+     * When set, the resolver falls through to a GitHub release download after the
+     * local-discovery tiers miss. Omit to keep the resolver read-only.
+     */
+    downloadIfMissing?: {
+        version: string;
+        integrity?: HashSpec | undefined;
+        cacheDir?: string | undefined;
+        downloader?: BinaryDownloader | undefined;
+    } | undefined;
+}
+export declare function cacheKey(opts: ResolveSbtOptions | undefined): string;
+export declare function doResolveSbt(opts?: ResolveSbtOptions | undefined): Promise<ResolvedSbt | undefined>;
+export declare function resetSbtResolution(): void;
+export declare function resolveSbt(opts?: ResolveSbtOptions | undefined): Promise<ResolvedSbt | undefined>;

package/dist/external-tools/sbt/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,
+  doResolveSbt: () => doResolveSbt,
+  resetSbtResolution: () => resetSbtResolution,
+  resolveSbt: () => resolveSbt
+});
+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, version } = opts.downloadIfMissing;
+  const integrityKey = typeof integrity === "string" ? integrity : integrity ? `${integrity.type}:${integrity.value}` : "";
+  return `dl:${version}:${integrityKey}:${cacheDir ?? ""}`;
+}
+async function doResolveSbt(opts) {
+  const fromVfs = await (0, import_from_vfs.sbtFromVfs)();
+  if (fromVfs) {
+    return fromVfs;
+  }
+  const fromPath = await (0, import_from_path.sbtFromPath)();
+  if (fromPath) {
+    return fromPath;
+  }
+  if (opts?.downloadIfMissing) {
+    return (0, import_from_download.sbtFromDownload)(opts.downloadIfMissing);
+  }
+  return void 0;
+}
+function resetSbtResolution() {
+  resolutionCache.clear();
+}
+function resolveSbt(opts) {
+  const key = cacheKey(opts);
+  let cached = resolutionCache.get(key);
+  if (!cached) {
+    cached = doResolveSbt(opts);
+    resolutionCache.set(key, cached);
+  }
+  return cached;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cacheKey,
+  doResolveSbt,
+  resetSbtResolution,
+  resolveSbt
+});

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

@@ -0,0 +1,32 @@
+/**
+ * @file Shared types for SBT resolution. SBT (Scala Build Tool) is JVM-based. A
+ *   "resolved SBT" is a launcher — either the `sbt` shell script on the user's
+ *   PATH, or the `sbt-launch.jar` extracted from the smol binary's VFS. In the
+ *   VFS case, the caller is responsible for invoking the launcher with `java
+ *   -jar <launcherPath>` using the JRE resolved via `resolveJre()`.
+ */
+import type { ResolvedToolIntegrity } from '../from-download';
+export type SbtSource = 'download' | 'path' | 'vfs';
+/**
+ * A resolved SBT launcher.
+ */
+export interface ResolvedSbt {
+    /**
+     * Absolute path to the launcher.
+     *
+     * - `source === 'path'`: the user's `sbt` script (invoke directly)
+     * - `source === 'vfs'`: the bundled `sbt-launch.jar` (invoke as `java -jar
+     *   <path>` via the resolved JRE)
+     */
+    readonly path: string;
+    /**
+     * `true` if `path` is a Java archive (`*.jar`) that must be invoked via `java
+     * -jar`; `false` if it's a direct-executable script.
+     */
+    readonly isJar: boolean;
+    readonly source: SbtSource;
+    /**
+     * See {@link ResolvedToolIntegrity}.
+     */
+    readonly integrity?: ResolvedToolIntegrity;
+}