@socketsecurity/lib 6.0.7 → 6.0.9

package/dist/external-tools/python/uv-install.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @file Uv project install helpers — the locked-source-of-truth half of the
+ *   "uv project + dlx materialize" model.
+ *   uv (Astral's Python package manager) drives a uv PROJECT — a directory with
+ *   `pyproject.toml` + `uv.lock` (+ optional `[tool.uv] exclude-newer`). The
+ *   lock manifests every transitive version, so the project is the most
+ *   locked-down, most-version-pinned form a Python tool install can take.
+ *   Two entry points, used together:
+ *
+ *   1. `uvSyncProject` — `uv sync --locked --project <dir>`. Installs the lock's
+ *      exact closure into the project's own `.venv` and FAILS if `uv.lock` is
+ *      out of date vs `pyproject.toml` (the `--locked` gate). This is the
+ *      verification-grade install: it proves the lock resolves.
+ *   2. `uvExportMaterialize` — `uv export --locked` → a flat, hash-pinned
+ *      requirements list, then `uv pip install --target <dir>` into a
+ *      content-addressed dlx dir (no venv → no symlinks / absolute `home=`, so
+ *      the result is relocatable + SEA-VFS-embeddable). Mirrors
+ *      `downloadPipPackage`'s lock-guarded, idempotent shape. Both take an
+ *      explicit `uvBin` (typically `resolveUv().path`) and never mutate a
+ *      shared interpreter — the project venv and the dlx target are
+ *      self-contained.
+ */
+/**
+ * Export a uv project's locked closure to a flat requirements list, then
+ * `uv pip install --target` it into a content-addressed dlx dir. The dlx dir
+ * holds plain files (no venv), so it is relocatable and embeddable in a smol
+ * binary's VFS — the bundle-safe analog of `uvSyncProject`'s `.venv`.
+ *
+ * Lock-guarded + idempotent (reuses `pip-install`'s `isAlreadyInstalled` /
+ * `isStaleLock`): a non-empty target dir short-circuits, and concurrent callers
+ * serialize on a `.installing` sentinel one level up from the target. Throws on
+ * a failed uv command or if the lock can't be acquired after MAX_RETRIES.
+ */
+export declare function uvExportMaterialize(options: UvExportMaterializeOptions, retryCount?: number): Promise<UvExportMaterializeResult>;
+/**
+ * Content-addressed dlx dir for a uv project's materialized closure:
+ * `~/.socket/_dlx/<cacheKey(projectDir)>/site-packages`. Keyed on the project
+ * dir so each project gets an isolated target; the analog of `pipPackageDir`.
+ */
+export declare function uvProjectTargetDir(projectDir: string): string;
+/**
+ * Run `uv sync --locked` against a uv project. Installs the lock's exact
+ * dependency closure into the project's `.venv`; the `--locked` flag turns a
+ * lock-vs-manifest drift into a hard failure (uv exits non-zero) rather than a
+ * silent re-resolution — this is what makes it verification-grade. Throws when
+ * uv exits non-zero (drift, missing lock, or a resolution failure).
+ */
+export declare function uvSyncProject(options: UvSyncProjectOptions): Promise<void>;
+export interface UvSyncProjectOptions {
+    /**
+     * Absolute path to the `uv` executable (typically `resolveUv().path`).
+     */
+    readonly uvBin: string;
+    /**
+     * Absolute path to the uv project dir (holds `pyproject.toml` + `uv.lock`).
+     */
+    readonly projectDir: string;
+    /**
+     * Default true — pass `--locked` so a lock-vs-manifest drift fails hard.
+     * Set false ONLY to bootstrap/refresh a lock (never in a verify path).
+     */
+    readonly locked?: boolean | undefined;
+}
+export interface UvExportMaterializeOptions {
+    /**
+     * Absolute path to the `uv` executable.
+     */
+    readonly uvBin: string;
+    /**
+     * Absolute path to the uv project dir to export from.
+     */
+    readonly projectDir: string;
+    /**
+     * Override the content-addressed target dir. Defaults to
+     * `uvProjectTargetDir(projectDir)`.
+     */
+    readonly targetDir?: string | undefined;
+}
+export interface UvExportMaterializeResult {
+    /**
+     * `true` when this call ran uv; `false` when an existing install was reused.
+     */
+    readonly installed: boolean;
+    /**
+     * Directory the closure was installed into. Put this on `PYTHONPATH` to run
+     * the tool: `python -m <module>`.
+     */
+    readonly targetDir: string;
+}

package/dist/external-tools/python/uv-install.js

@@ -0,0 +1,165 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_constants_platform = require('../../constants/platform.js');
+const require_process_spawn_child = require('../../process/spawn/child.js');
+const require_paths_socket = require('../../paths/socket.js');
+const require_fs_safe = require('../../fs/safe.js');
+const require_dlx_cache = require('../../dlx/cache.js');
+const require_external_tools_python_pip_install = require('./pip-install.js');
+let node_fs = require("node:fs");
+let node_process = require("node:process");
+node_process = require_runtime.__toESM(node_process);
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+
+//#region src/external-tools/python/uv-install.ts
+/**
+* @file Uv project install helpers — the locked-source-of-truth half of the
+*   "uv project + dlx materialize" model.
+*   uv (Astral's Python package manager) drives a uv PROJECT — a directory with
+*   `pyproject.toml` + `uv.lock` (+ optional `[tool.uv] exclude-newer`). The
+*   lock manifests every transitive version, so the project is the most
+*   locked-down, most-version-pinned form a Python tool install can take.
+*   Two entry points, used together:
+*
+*   1. `uvSyncProject` — `uv sync --locked --project <dir>`. Installs the lock's
+*      exact closure into the project's own `.venv` and FAILS if `uv.lock` is
+*      out of date vs `pyproject.toml` (the `--locked` gate). This is the
+*      verification-grade install: it proves the lock resolves.
+*   2. `uvExportMaterialize` — `uv export --locked` → a flat, hash-pinned
+*      requirements list, then `uv pip install --target <dir>` into a
+*      content-addressed dlx dir (no venv → no symlinks / absolute `home=`, so
+*      the result is relocatable + SEA-VFS-embeddable). Mirrors
+*      `downloadPipPackage`'s lock-guarded, idempotent shape. Both take an
+*      explicit `uvBin` (typically `resolveUv().path`) and never mutate a
+*      shared interpreter — the project venv and the dlx target are
+*      self-contained.
+*/
+const MAX_RETRIES = 3;
+const WAIT_TICKS = 30;
+/**
+* Export a uv project's locked closure to a flat requirements list, then
+* `uv pip install --target` it into a content-addressed dlx dir. The dlx dir
+* holds plain files (no venv), so it is relocatable and embeddable in a smol
+* binary's VFS — the bundle-safe analog of `uvSyncProject`'s `.venv`.
+*
+* Lock-guarded + idempotent (reuses `pip-install`'s `isAlreadyInstalled` /
+* `isStaleLock`): a non-empty target dir short-circuits, and concurrent callers
+* serialize on a `.installing` sentinel one level up from the target. Throws on
+* a failed uv command or if the lock can't be acquired after MAX_RETRIES.
+*/
+async function uvExportMaterialize(options, retryCount = 0) {
+	const opts = {
+		__proto__: null,
+		...options
+	};
+	const { projectDir, uvBin } = opts;
+	const targetDir = opts.targetDir ?? uvProjectTargetDir(projectDir);
+	if (retryCount >= MAX_RETRIES) throw new Error(`uvExportMaterialize: could not acquire install lock after ${MAX_RETRIES} retries for ${targetDir}; a peer may be stuck or the lock is stale — remove it and retry`);
+	if (await require_external_tools_python_pip_install.isAlreadyInstalled(targetDir)) return {
+		installed: false,
+		targetDir
+	};
+	const lockDir = node_path.default.dirname(targetDir);
+	await require_fs_safe.safeMkdir(lockDir, { recursive: true });
+	const lockFile = node_path.default.join(lockDir, ".installing");
+	try {
+		await node_fs.promises.writeFile(lockFile, node_process.default.pid.toString(), { flag: "wx" });
+	} catch (e) {
+		if (e.code !== "EEXIST") throw e;
+		let stale = false;
+		try {
+			stale = require_external_tools_python_pip_install.isStaleLock(Number.parseInt((await node_fs.promises.readFile(lockFile, "utf8")).trim(), 10));
+		} catch {
+			stale = true;
+		}
+		if (stale) {
+			await require_fs_safe.safeDelete(lockFile, { force: true });
+			return uvExportMaterialize(options, retryCount + 1);
+		}
+		for (let i = 0; i < WAIT_TICKS; i += 1) {
+			await new Promise((resolve) => {
+				setTimeout(resolve, 1e3);
+			});
+			if (await require_external_tools_python_pip_install.isAlreadyInstalled(targetDir)) return {
+				installed: false,
+				targetDir
+			};
+		}
+		return uvExportMaterialize(options, retryCount + 1);
+	}
+	try {
+		await require_fs_safe.safeMkdir(targetDir, { recursive: true });
+		const requirementsPath = node_path.default.join(lockDir, "requirements.locked.txt");
+		await require_process_spawn_child.spawn(uvBin, [
+			"export",
+			"--locked",
+			"--no-emit-project",
+			"--no-dev",
+			"--project",
+			projectDir,
+			"--output-file",
+			requirementsPath
+		], {
+			shell: require_constants_platform.WIN32,
+			stdio: "inherit"
+		});
+		await require_process_spawn_child.spawn(uvBin, [
+			"pip",
+			"install",
+			"--target",
+			targetDir,
+			"--requirement",
+			requirementsPath
+		], {
+			shell: require_constants_platform.WIN32,
+			stdio: "inherit"
+		});
+		await require_fs_safe.safeDelete(requirementsPath, { force: true });
+		if (!await require_external_tools_python_pip_install.isAlreadyInstalled(targetDir)) throw new Error(`uvExportMaterialize: uv pip install --target ${targetDir} reported success but the target is still empty`);
+		return {
+			installed: true,
+			targetDir
+		};
+	} finally {
+		await require_fs_safe.safeDelete(lockFile, { force: true });
+	}
+}
+/**
+* Content-addressed dlx dir for a uv project's materialized closure:
+* `~/.socket/_dlx/<cacheKey(projectDir)>/site-packages`. Keyed on the project
+* dir so each project gets an isolated target; the analog of `pipPackageDir`.
+*/
+function uvProjectTargetDir(projectDir) {
+	return node_path.default.join(require_paths_socket.getSocketDlxDir(), require_dlx_cache.generateCacheKey(projectDir), "site-packages");
+}
+/**
+* Run `uv sync --locked` against a uv project. Installs the lock's exact
+* dependency closure into the project's `.venv`; the `--locked` flag turns a
+* lock-vs-manifest drift into a hard failure (uv exits non-zero) rather than a
+* silent re-resolution — this is what makes it verification-grade. Throws when
+* uv exits non-zero (drift, missing lock, or a resolution failure).
+*/
+async function uvSyncProject(options) {
+	const opts = {
+		__proto__: null,
+		...options
+	};
+	const { projectDir, uvBin } = opts;
+	await require_process_spawn_child.spawn(uvBin, [
+		"sync",
+		...opts.locked === false ? [] : ["--locked"],
+		"--project",
+		projectDir
+	], {
+		shell: require_constants_platform.WIN32,
+		stdio: "inherit"
+	});
+}
+
+//#endregion
+exports.uvExportMaterialize = uvExportMaterialize;
+exports.uvProjectTargetDir = uvProjectTargetDir;
+exports.uvSyncProject = uvSyncProject;

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

@@ -28,4 +28,4 @@ export interface SbtDownloadOptions {
  *   // → 'https://github.com/sbt/sbt/releases/download/v1.10.7/sbt-1.10.7.tgz'
  *   ```
  */
-export declare function getSbtDownloadUrl(opts: SbtDownloadOptions): string;
+export declare function getSbtDownloadUrl(options: SbtDownloadOptions): string;

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

@@ -15,8 +15,11 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 *   // → 'https://github.com/sbt/sbt/releases/download/v1.10.7/sbt-1.10.7.tgz'
 *   ```
 */
-function getSbtDownloadUrl(opts) {
-	const { version } = opts;
+function getSbtDownloadUrl(options) {
+	const { version } = {
+		__proto__: null,
+		...options
+	};
 	return `https://github.com/sbt/sbt/releases/download/v${version}/sbt-${version}.tgz`;
 }
 

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

@@ -41,4 +41,4 @@ export interface SbtFromDownloadOptions {
  *   // → { path: '/.../bin/sbt', isJar: false, source: 'download' }
  *   ```
  */
-export declare function sbtFromDownload(opts: SbtFromDownloadOptions): Promise<ResolvedSbt | undefined>;
+export declare function sbtFromDownload(options: SbtFromDownloadOptions): Promise<ResolvedSbt | undefined>;

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

@@ -29,8 +29,11 @@ node_path = require_runtime.__toESM(node_path);
 *   // → { path: '/.../bin/sbt', isJar: false, source: 'download' }
 *   ```
 */
-async function sbtFromDownload(opts) {
-	const { cacheDir, downloader, integrity, version } = opts;
+async function sbtFromDownload(options) {
+	const { cacheDir, downloader, integrity, version } = {
+		__proto__: null,
+		...options
+	};
 	const url = require_external_tools_sbt_asset_names.getSbtDownloadUrl({ version });
 	const extractedDir = cacheDir ?? node_path.default.join(require_paths_socket.getSocketDlxDir(), "sbt", version);
 	const archive = await require_external_tools_from_download.downloadAndExtractTool({

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

@@ -25,7 +25,7 @@ export interface ResolveSbtOptions {
         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 cacheKey(options: ResolveSbtOptions | undefined): string;
+export declare function doResolveSbt(options?: ResolveSbtOptions | undefined): Promise<ResolvedSbt | undefined>;
 export declare function resetSbtResolution(): void;
-export declare function resolveSbt(opts?: ResolveSbtOptions | undefined): Promise<ResolvedSbt | undefined>;
+export declare function resolveSbt(options?: ResolveSbtOptions | undefined): Promise<ResolvedSbt | undefined>;

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

@@ -20,30 +20,38 @@ const require_external_tools_sbt_from_vfs = require('./from-vfs.js');
 *      Memoized per option-shape.
 */
 const resolutionCache = new require_primordials_map_set.MapCtor();
-function cacheKey(opts) {
-	if (!opts?.downloadIfMissing) return "local-only";
-	const { cacheDir, integrity, version } = opts.downloadIfMissing;
+function cacheKey(options) {
+	options = {
+		__proto__: null,
+		...options
+	};
+	if (!options?.downloadIfMissing) return "local-only";
+	const { cacheDir, integrity, version } = options.downloadIfMissing;
 	return `dl:${version}:${typeof integrity === "string" ? integrity : integrity ? `${integrity.type}:${integrity.value}` : ""}:${cacheDir ?? ""}`;
 }
-async function doResolveSbt(opts) {
+async function doResolveSbt(options) {
+	options = {
+		__proto__: null,
+		...options
+	};
 	const fromVfs = await require_external_tools_sbt_from_vfs.sbtFromVfs();
 	/* c8 ignore start - smol Node binary only. */
 	if (fromVfs) return fromVfs;
 	/* c8 ignore stop */
 	const fromPath = await require_external_tools_sbt_from_path.sbtFromPath();
 	if (fromPath) return fromPath;
-	if (opts?.downloadIfMissing) return require_external_tools_sbt_from_download.sbtFromDownload(opts.downloadIfMissing);
+	if (options?.downloadIfMissing) return require_external_tools_sbt_from_download.sbtFromDownload(options.downloadIfMissing);
 }
 /* c8 ignore start - test-only escape hatch. */
 function resetSbtResolution() {
 	resolutionCache.clear();
 }
 /* c8 ignore stop */
-function resolveSbt(opts) {
-	const key = cacheKey(opts);
+function resolveSbt(options) {
+	const key = cacheKey(options);
 	let cached = resolutionCache.get(key);
 	if (!cached) {
-		cached = doResolveSbt(opts);
+		cached = doResolveSbt(options);
 		resolutionCache.set(key, cached);
 	}
 	return cached;

package/dist/external-tools/skillspector/from-dlx.d.ts

@@ -21,4 +21,4 @@ export interface SkillSpectorFromDlxOptions {
      */
     readonly cacheDir?: string | undefined;
 }
-export declare function skillspectorFromDlx(opts: SkillSpectorFromDlxOptions): Promise<ResolvedSkillSpector | undefined>;
+export declare function skillspectorFromDlx(options: SkillSpectorFromDlxOptions): Promise<ResolvedSkillSpector | undefined>;

package/dist/external-tools/skillspector/from-dlx.js

@@ -18,10 +18,17 @@ node_path = require_runtime.__toESM(node_path);
 *     venv when its `skillspector` entry-point already exists.
 */
 const UPSTREAM_REPO = "https://github.com/NVIDIA/skillspector.git";
-async function skillspectorFromDlx(opts) {
-	const { sha } = opts;
+async function skillspectorFromDlx(options) {
+	options = {
+		__proto__: null,
+		...options
+	};
+	const { sha } = {
+		__proto__: null,
+		...options
+	};
 	if (!sha) return;
-	const cacheDir = opts.cacheDir ?? node_path.default.join(require_paths_socket.getSocketDlxDir(), "skillspector", sha);
+	const cacheDir = options.cacheDir ?? node_path.default.join(require_paths_socket.getSocketDlxDir(), "skillspector", sha);
 	const installSpec = `git+${UPSTREAM_REPO}@${sha}`;
 	try {
 		return {

package/dist/external-tools/skillspector/from-uv.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @file `skillspectorFromUv()` — locked-uv-project tier of SkillSpector
+ *   resolution. Given a uv project dir (a `pyproject.toml` + `uv.lock` that pin
+ *   the upstream git SHA + its full transitive closure) and a resolved `uv`
+ *   binary, runs `uv sync --locked` to install that exact closure into the
+ *   project's `.venv` and returns the `skillspector` entry point. This is the
+ *   most locked-down tier — every dependency version is manifested in uv.lock,
+ *   and `--locked` hard-fails on lock drift (vs. `from-dlx`'s pip-from-git-SHA
+ *   venv, which re-resolves the closure freshly). Returns `undefined` when:
+ *
+ *   - No project dir / uv binary is supplied (the caller didn't opt in).
+ *   - The project files are absent, or `uv sync --locked` fails (lock drift, no
+ *     network, missing Python). Idempotent: a second call hits the synced venv
+ *     (`uv sync` is a no-op when the venv already matches the lock).
+ */
+import type { ResolvedSkillSpector } from './types';
+export interface SkillSpectorFromUvOptions {
+    /**
+     * Absolute path to the `uv` executable (typically `resolveUv().path`).
+     */
+    readonly uvBin: string;
+    /**
+     * Absolute path to the SkillSpector uv project dir (holds `pyproject.toml` +
+     * `uv.lock`). The fleet ships this under
+     * `setup-security-tools/skillspector/`.
+     */
+    readonly projectDir: string;
+}
+export declare function skillspectorFromUv(options: SkillSpectorFromUvOptions): Promise<ResolvedSkillSpector | undefined>;
+export declare function venvEntryPoint(projectDir: string): string;

package/dist/external-tools/skillspector/from-uv.js

@@ -0,0 +1,56 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_external_tools_python_uv_install = require('../python/uv-install.js');
+let node_fs = require("node:fs");
+let node_process = require("node:process");
+node_process = require_runtime.__toESM(node_process);
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+
+//#region src/external-tools/skillspector/from-uv.ts
+/**
+* @file `skillspectorFromUv()` — locked-uv-project tier of SkillSpector
+*   resolution. Given a uv project dir (a `pyproject.toml` + `uv.lock` that pin
+*   the upstream git SHA + its full transitive closure) and a resolved `uv`
+*   binary, runs `uv sync --locked` to install that exact closure into the
+*   project's `.venv` and returns the `skillspector` entry point. This is the
+*   most locked-down tier — every dependency version is manifested in uv.lock,
+*   and `--locked` hard-fails on lock drift (vs. `from-dlx`'s pip-from-git-SHA
+*   venv, which re-resolves the closure freshly). Returns `undefined` when:
+*
+*   - No project dir / uv binary is supplied (the caller didn't opt in).
+*   - The project files are absent, or `uv sync --locked` fails (lock drift, no
+*     network, missing Python). Idempotent: a second call hits the synced venv
+*     (`uv sync` is a no-op when the venv already matches the lock).
+*/
+async function skillspectorFromUv(options) {
+	const { projectDir, uvBin } = {
+		__proto__: null,
+		...options
+	};
+	if (!projectDir || !uvBin) return;
+	if (!(0, node_fs.existsSync)(node_path.default.join(projectDir, "pyproject.toml")) || !(0, node_fs.existsSync)(node_path.default.join(projectDir, "uv.lock"))) return;
+	try {
+		await require_external_tools_python_uv_install.uvSyncProject({
+			projectDir,
+			uvBin
+		});
+	} catch {
+		return;
+	}
+	const entry = venvEntryPoint(projectDir);
+	if (!(0, node_fs.existsSync)(entry)) return;
+	return {
+		path: entry,
+		source: "uv"
+	};
+}
+function venvEntryPoint(projectDir) {
+	return node_process.default.platform === "win32" ? node_path.default.join(projectDir, ".venv", "Scripts", "skillspector.exe") : node_path.default.join(projectDir, ".venv", "bin", "skillspector");
+}
+
+//#endregion
+exports.skillspectorFromUv = skillspectorFromUv;
+exports.venvEntryPoint = venvEntryPoint;

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

@@ -5,9 +5,13 @@
  *   1. VFS — smol binary's embedded skillspector (if packed)
  *   2. PATH — `which skillspector` (pipx-installed binaries land here too; the
  *      source field distinguishes `'pipx'` vs `'path'`)
- *   3. DLX-venv — `~/.socket/_dlx/skillspector/<sha>/` with the pinned SHA Returns
+ *   3. UV-project — `uv sync --locked` against a uv project (the most locked-down
+ *      tier; every transitive version pinned in uv.lock). Only runs when
+ *      `uvProjectDir` + `uvBin` are supplied.
+ *   4. DLX-venv — `~/.socket/_dlx/skillspector/<sha>/` with the pinned SHA (the
+ *      pip-from-git-SHA fallback when no uv project is available). Returns
  *      `undefined` when all enabled sources miss. Memoized per
- *      sha+cacheDir+localOnly tuple.
+ *      sha+cacheDir+uvProjectDir+localOnly tuple.
  */
 import type { ResolvedSkillSpector } from './types';
 export interface ResolveSkillSpectorOptions {
@@ -17,17 +21,28 @@ export interface ResolveSkillSpectorOptions {
      */
     readonly sha?: string | undefined;
     /**
-     * Tier-3 cache override. Defaults to `~/.socket/_dlx/skillspector/<sha>`.
+     * DLX cache override. Defaults to `~/.socket/_dlx/skillspector/<sha>`.
      */
     readonly cacheDir?: string | undefined;
+    /**
+     * UV-project tier: absolute path to a uv project dir (a `pyproject.toml` +
+     * `uv.lock` pinning the SHA + its closure). When set together with `uvBin`,
+     * the locked-uv tier runs ahead of the DLX-venv tier.
+     */
+    readonly uvProjectDir?: string | undefined;
+    /**
+     * UV-project tier: absolute path to the `uv` executable
+     * (typically `resolveUv().path`). Required to run the locked-uv tier.
+     */
+    readonly uvBin?: string | undefined;
     /**
      * When true, only the VFS + PATH tiers run. Use for check-mode invocations
      * that want to fail-fast if the tool isn't already installed.
      */
     readonly localOnly?: boolean | undefined;
 }
-export declare function cacheKey(opts: ResolveSkillSpectorOptions): string;
-export declare function doResolveSkillSpector(opts: ResolveSkillSpectorOptions): Promise<ResolvedSkillSpector | undefined>;
+export declare function cacheKey(options: ResolveSkillSpectorOptions): string;
+export declare function doResolveSkillSpector(options: ResolveSkillSpectorOptions): Promise<ResolvedSkillSpector | undefined>;
 /**
  * Memoizing wrapper around {@link doResolveSkillSpector}.
  */

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_primordials_map_set = require('../../primordials/map-set.js');
 const require_external_tools_skillspector_from_dlx = require('./from-dlx.js');
 const require_external_tools_skillspector_from_path = require('./from-path.js');
+const require_external_tools_skillspector_from_uv = require('./from-uv.js');
 const require_external_tools_skillspector_from_vfs = require('./from-vfs.js');
 
 //#region src/external-tools/skillspector/resolve.ts
@@ -14,22 +15,42 @@ const require_external_tools_skillspector_from_vfs = require('./from-vfs.js');
 *   1. VFS — smol binary's embedded skillspector (if packed)
 *   2. PATH — `which skillspector` (pipx-installed binaries land here too; the
 *      source field distinguishes `'pipx'` vs `'path'`)
-*   3. DLX-venv — `~/.socket/_dlx/skillspector/<sha>/` with the pinned SHA Returns
+*   3. UV-project — `uv sync --locked` against a uv project (the most locked-down
+*      tier; every transitive version pinned in uv.lock). Only runs when
+*      `uvProjectDir` + `uvBin` are supplied.
+*   4. DLX-venv — `~/.socket/_dlx/skillspector/<sha>/` with the pinned SHA (the
+*      pip-from-git-SHA fallback when no uv project is available). Returns
 *      `undefined` when all enabled sources miss. Memoized per
-*      sha+cacheDir+localOnly tuple.
+*      sha+cacheDir+uvProjectDir+localOnly tuple.
 */
 const resolutionCache = new require_primordials_map_set.MapCtor();
-function cacheKey(opts) {
-	return `${opts.sha ?? ""}|${opts.cacheDir ?? ""}|${opts.localOnly ? "local" : "full"}`;
+function cacheKey(options) {
+	const opts = {
+		__proto__: null,
+		...options
+	};
+	return `${opts.sha ?? ""}|${opts.cacheDir ?? ""}|${opts.uvProjectDir ?? ""}|${opts.localOnly ? "local" : "full"}`;
 }
-async function doResolveSkillSpector(opts) {
+async function doResolveSkillSpector(options) {
+	const opts = {
+		__proto__: null,
+		...options
+	};
 	const fromVfs = await require_external_tools_skillspector_from_vfs.skillspectorFromVfs();
 	/* c8 ignore start - smol Node binary only. */
 	if (fromVfs) return fromVfs;
 	/* c8 ignore stop */
 	const fromPath = await require_external_tools_skillspector_from_path.skillspectorFromPath();
 	if (fromPath) return fromPath;
-	if (opts.localOnly || !opts.sha) return;
+	if (opts.localOnly) return;
+	if (opts.uvProjectDir && opts.uvBin) {
+		const fromUv = await require_external_tools_skillspector_from_uv.skillspectorFromUv({
+			projectDir: opts.uvProjectDir,
+			uvBin: opts.uvBin
+		});
+		if (fromUv) return fromUv;
+	}
+	if (!opts.sha) return;
 	return require_external_tools_skillspector_from_dlx.skillspectorFromDlx({
 		sha: opts.sha,
 		cacheDir: opts.cacheDir

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

@@ -3,7 +3,7 @@
  *   third-party-skill scanner (sibling to AgentShield); pinned to a git SHA
  *   because upstream has no PyPI release or GH tags as of 2026-06-01.
  */
-export type SkillSpectorSource = 'vfs' | 'pipx' | 'path' | 'dlx';
+export type SkillSpectorSource = 'vfs' | 'pipx' | 'path' | 'uv' | 'dlx';
 /**
  * A resolved SkillSpector installation.
  */
@@ -18,6 +18,8 @@ export interface ResolvedSkillSpector {
      * - 'vfs' — extracted from the SEA binary's VFS
      * - 'pipx' — `which skillspector` returned a pipx-installed venv binary
      * - 'path' — `which skillspector` returned a non-pipx binary on PATH
+     * - 'uv' — `uv sync --locked` against a uv project's .venv (the most
+     *   locked-down tier; every transitive version pinned in uv.lock)
      * - 'dlx' — created a venv under ~/.socket/_dlx/skillspector/<sha>/
      */
     readonly source: SkillSpectorSource;

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

@@ -11,4 +11,4 @@ export interface SynpPackageOptions {
 /**
  * Build the npm package spec string for the requested synp version.
  */
-export declare function getSynpPackageSpec(opts: SynpPackageOptions): string;
+export declare function getSynpPackageSpec(options: SynpPackageOptions): string;

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

@@ -6,8 +6,12 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 /**
 * Build the npm package spec string for the requested synp version.
 */
-function getSynpPackageSpec(opts) {
-	return `synp@${opts.version}`;
+function getSynpPackageSpec(options) {
+	options = {
+		__proto__: null,
+		...options
+	};
+	return `synp@${options.version}`;
 }
 
 //#endregion

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

@@ -15,4 +15,4 @@ export interface SynpFromDownloadOptions {
      */
     integrity?: string | undefined;
 }
-export declare function synpFromDownload(opts: SynpFromDownloadOptions): Promise<ResolvedSynp>;
+export declare function synpFromDownload(options: SynpFromDownloadOptions): Promise<ResolvedSynp>;

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

@@ -10,8 +10,11 @@ const require_external_tools_synp_asset_names = require('./asset-names.js');
 *   `dlx/package` and returns a `ResolvedSynp` pointing at the resolved bin
 *   shim.
 */
-async function synpFromDownload(opts) {
-	const { integrity, version } = opts;
+async function synpFromDownload(options) {
+	const { integrity, version } = {
+		__proto__: null,
+		...options
+	};
 	const { binaryPath } = await require_dlx_package.downloadNpmPackage({
 		spec: require_external_tools_synp_asset_names.getSynpPackageSpec({ version }),
 		binaryName: "synp",

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

@@ -15,7 +15,7 @@ export interface ResolveSynpOptions {
         integrity?: string | undefined;
     } | undefined;
 }
-export declare function cacheKey(opts: ResolveSynpOptions | undefined): string;
-export declare function doResolveSynp(opts?: ResolveSynpOptions | undefined): Promise<ResolvedSynp | undefined>;
+export declare function cacheKey(options: ResolveSynpOptions | undefined): string;
+export declare function doResolveSynp(options?: ResolveSynpOptions | undefined): Promise<ResolvedSynp | undefined>;
 export declare function resetSynpResolution(): void;
-export declare function resolveSynp(opts?: ResolveSynpOptions | undefined): Promise<ResolvedSynp | undefined>;
+export declare function resolveSynp(options?: ResolveSynpOptions | undefined): Promise<ResolvedSynp | undefined>;