@vltpkg/cli-sdk 1.0.0-rc.22 → 1.0.0-rc.24

package/dist/query-host-contexts.d.ts

@@ -0,0 +1,15 @@
+import { SecurityArchive } from '@vltpkg/security-archive';
+import type { EdgeLike, NodeLike } from '@vltpkg/types';
+import type { LoadedConfig } from './config/index.ts';
+export type HostContextsMapResult = {
+    initialEdges: EdgeLike[];
+    initialNodes: NodeLike[];
+    edges: EdgeLike[];
+    nodes: NodeLike[];
+    securityArchive: SecurityArchive;
+};
+/**
+ * Creates a Map of host context functions that can be used by the :host
+ * pseudo selector to dynamically load graphs from different sources.
+ */
+export declare const createHostContextsMap: (conf: LoadedConfig) => Promise<Map<string, () => Promise<HostContextsMapResult>>>;

package/dist/query-host-contexts.js

@@ -0,0 +1,136 @@
+import { homedir } from 'node:os';
+import { parse, posix } from 'node:path';
+import { readProjectFolders } from "./read-project-folders.js";
+import { reloadConfig } from "./reload-config.js";
+import { actual, createVirtualRoot } from '@vltpkg/graph';
+import { SecurityArchive } from '@vltpkg/security-archive';
+import { error } from '@vltpkg/error-cause';
+// In restricted environments (like locked-down Codespaces),
+// homedir() might fail. Fall back to parent directory.
+let foundHome;
+try {
+    foundHome = posix.format(parse(homedir()));
+    /* c8 ignore next 3 */
+}
+catch { }
+const home = foundHome ?? posix.dirname(posix.format(parse(process.cwd())));
+const isVltInstalled = (folder) => !!folder.resolve('node_modules/.vlt').lstatSync()?.isDirectory() ||
+    !!folder
+        .resolve('node_modules/.vlt-lock.json')
+        .lstatSync()
+        ?.isFile();
+/**
+ * Generates possible project keys for a given folder.
+ */
+const getPossibleProjectKeys = (folder, scurry) => {
+    const relativePath = posix.relative(scurry.cwd.fullpathPosix(), folder.fullpathPosix());
+    const absolutePath = folder.fullpathPosix();
+    const homeRelativePath = posix.relative(scurry.resolvePosix(home), folder.fullpathPosix());
+    const dotRelativeKey = relativePath === '' ? 'file:.' : `file:./${relativePath}`;
+    const relativeKey = `file:${relativePath}`;
+    const absoluteKey = `file:${absolutePath}`;
+    const homeRelativeKey = `file:~/${homeRelativePath}`;
+    const keys = [
+        relativeKey,
+        dotRelativeKey,
+        absoluteKey,
+        homeRelativeKey,
+        `${relativeKey}/`,
+        `${dotRelativeKey}/`,
+        `${absoluteKey}/`,
+        `${homeRelativeKey}/`,
+    ];
+    return new Set(keys);
+};
+/**
+ * Creates a Map of host context functions that can be used by the :host
+ * pseudo selector to dynamically load graphs from different sources.
+ */
+export const createHostContextsMap = async (conf) => {
+    const hostContexts = new Map();
+    // Read all project folders from the configured paths
+    const { scurry } = conf.options;
+    const projectFolders = await readProjectFolders({
+        scurry,
+        userDefinedProjectPaths: conf.options['dashboard-root'] ?? [],
+    });
+    for (const folder of projectFolders) {
+        const retrieveProjectGraph = async () => {
+            const initialEdges = [];
+            const initialNodes = [];
+            const config = await reloadConfig(folder.fullpath());
+            // load each individual graph
+            const graph = actual.load({
+                ...config.options,
+                projectRoot: folder.fullpath(),
+                skipLoadingNodesOnModifiersChange: false,
+            });
+            initialEdges.push(...graph.edges);
+            initialNodes.push(...graph.nodes.values());
+            // Initialize security archive with all loaded nodes
+            const securityArchive = await SecurityArchive.start({
+                nodes: initialNodes,
+            });
+            return {
+                initialEdges,
+                initialNodes,
+                edges: [],
+                nodes: [graph.mainImporter],
+                securityArchive,
+            };
+        };
+        // add multiple keys for each project folder
+        for (const path of getPossibleProjectKeys(folder, scurry)) {
+            if (!hostContexts.has(path)) {
+                hostContexts.set(path, retrieveProjectGraph);
+            }
+        }
+    }
+    // Define local context - loads graphs from all projects in user's project paths
+    hostContexts.set('local', async () => {
+        // Load graphs from each project folder
+        const initialEdges = [];
+        const initialNodes = [];
+        const mainImporters = [];
+        for (const folder of projectFolders) {
+            try {
+                const config = await reloadConfig(folder.fullpath());
+                // only include projects that are vlt-installed
+                if (!isVltInstalled(folder)) {
+                    continue;
+                }
+                // load each individual graph
+                const graph = actual.load({
+                    ...config.options,
+                    projectRoot: folder.fullpath(),
+                    skipLoadingNodesOnModifiersChange: false,
+                });
+                initialEdges.push(...graph.edges);
+                initialNodes.push(...graph.nodes.values());
+                mainImporters.push(graph.mainImporter);
+            }
+            catch (_error) {
+                // Skip projects that fail to load
+                // This might happen for projects without proper package.json
+                // or other loading issues
+                continue;
+            }
+        }
+        // Initialize security archive with all loaded nodes
+        const securityArchive = await SecurityArchive.start({
+            nodes: initialNodes,
+        });
+        const virtualRoot = createVirtualRoot('local', conf.options, mainImporters);
+        if (!virtualRoot) {
+            throw error('Failed to create virtual root for local context');
+        }
+        return {
+            initialEdges,
+            initialNodes,
+            edges: [],
+            nodes: [virtualRoot],
+            securityArchive,
+        };
+    });
+    return hostContexts;
+};

package/dist/read-password.d.ts

@@ -0,0 +1,7 @@
+export type Streams = {
+    stdin: NodeJS.ReadableStream & {
+        setRawMode(mode: boolean): void;
+    };
+    stdout: NodeJS.WritableStream;
+};
+export declare const readPassword: (prompt: string, { stdin, stdout }?: Streams) => Promise<string>;

package/dist/read-password.js

@@ -0,0 +1,32 @@
+import { error } from '@vltpkg/error-cause';
+export const readPassword = async (prompt, { stdin, stdout } = process) => {
+    let input = '';
+    stdout.write(prompt);
+    stdin.setRawMode(true);
+    await new Promise((res, rej) => {
+        stdin.on('data', (c) => {
+            // backspace
+            if (c.length === 1 && c[0] === 0x7f) {
+                input = input.substring(0, input.length - 1);
+                stdout.write('\x1b[1D \x1b[1D');
+                return;
+            }
+            input += String(c);
+            if (/\r|\n|\x04|\x03/.test(input)) {
+                input = input.replace(/(\r|\n|\x04|\x03)/g, '');
+                stdin.setRawMode(false);
+                stdin.pause();
+                // x03 === ^C
+                if (c[c.length - 1] === 3) {
+                    rej(error('canceled', { signal: 'SIGINT' }));
+                }
+                else
+                    res();
+            }
+            else {
+                stdout.write('*'.repeat(c.length));
+            }
+        });
+    });
+    return input;
+};

package/dist/read-project-folders.d.ts

@@ -0,0 +1,17 @@
+import type { PathBase, PathScurry } from 'path-scurry';
+type ProjectFolderOptions = {
+    path?: string;
+    scurry: PathScurry;
+    userDefinedProjectPaths: string[];
+};
+/**
+ * Retrieves folders from a given directory, if that directory is
+ * recognized to be the current cli project root folder then we
+ * proceed to read its siblings.
+ *
+ * Traverses nested directory recursively until project folders can
+ * be find, always stopping at the first level where a package.json
+ * is present.
+ */
+export declare const readProjectFolders: ({ path, scurry, userDefinedProjectPaths, }: ProjectFolderOptions, maxDepth?: number) => Promise<PathBase[]>;
+export {};

package/dist/read-project-folders.js

@@ -0,0 +1,100 @@
+import { availableParallelism, homedir } from 'node:os';
+import { dirname } from 'node:path';
+import { callLimit } from 'promise-call-limit';
+const limit = Math.max(availableParallelism() - 1, 1) * 8;
+let home;
+try {
+    home = homedir();
+}
+catch {
+    home = dirname(process.cwd());
+}
+const ignoredHomedirFolderNames = [
+    'downloads',
+    'movies',
+    'music',
+    'pictures',
+    'private',
+    'library',
+    'dropbox',
+].concat(process.platform === 'darwin' ?
+    [
+        'public',
+        'private',
+        'applications',
+        'applications (parallels)',
+        'sites',
+        'sync',
+    ]
+    : process.platform === 'win32' ?
+        [
+            'appdata',
+            'application data',
+            'favorites',
+            'links',
+            'videos',
+            'contacts',
+            'searches',
+        ]
+        : ['videos', 'public']);
+/**
+ * Retrieves folders from a given directory, if that directory is
+ * recognized to be the current cli project root folder then we
+ * proceed to read its siblings.
+ *
+ * Traverses nested directory recursively until project folders can
+ * be find, always stopping at the first level where a package.json
+ * is present.
+ */
+export const readProjectFolders = async ({ path = home, scurry, userDefinedProjectPaths, }, maxDepth = 7) => {
+    const result = [];
+    const homeEntry = scurry.cwd.resolve(home);
+    const paths = userDefinedProjectPaths.length ? userDefinedProjectPaths : [path];
+    const step = (entry, depth) => async () => {
+        try {
+            for (const child of await entry.readdir()) {
+                if (await collectResult(child, result, scurry, entry === homeEntry, depth, maxDepth)) {
+                    traverse.push(step(child, depth + 1));
+                }
+            }
+            /* c8 ignore next 4 */
+        }
+        catch {
+            // Ignore directories that can't be read.
+            // This commonly happens in restricted environments.
+        }
+    };
+    let traverse = (await Promise.all(paths.map(path => scurry.lstat(path))))
+        .filter(p => !!p)
+        .map(p => step(p, 0));
+    // have to do it in phases this way because pushing into the queue
+    // during the promise-call-limit confuses its tracking.
+    let t;
+    do {
+        t = traverse;
+        traverse = [];
+        await callLimit(t, { limit });
+    } while (traverse.length);
+    return result;
+};
+const collectResult = async (entry, result, scurry, fromHome, depth, maxDepth) => {
+    if (!entry.isDirectory() ||
+        entry.isSymbolicLink() ||
+        entry.name === 'node_modules' ||
+        (fromHome &&
+            ignoredHomedirFolderNames.includes(entry.name.toLowerCase())) ||
+        entry.name.startsWith('.') ||
+        depth > maxDepth) {
+        return false;
+    }
+    const resolved = entry.fullpath();
+    const statPackageJson = await scurry
+        .lstat(`${resolved}/package.json`)
+        .catch(() => { });
+    const hasValidPackageJson = statPackageJson &&
+        statPackageJson.isFile() &&
+        !statPackageJson.isSymbolicLink();
+    if (hasValidPackageJson)
+        result.push(entry);
+    return !hasValidPackageJson;
+};

package/dist/reload-config.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedConfig } from './config/index.ts';
+export declare const reloadConfig: (folder: string) => Promise<ParsedConfig>;

package/dist/reload-config.js

@@ -0,0 +1,11 @@
+export const reloadConfig = async (folder) => {
+    try {
+        const { unload } = (await import('@vltpkg/vlt-json'));
+        unload('user');
+        unload('project');
+        /* c8 ignore next */
+    }
+    catch { }
+    const { Config } = await import("./config/index.js");
+    return Config.load(folder, process.argv, true);
+};

package/dist/render-mermaid.d.ts

@@ -0,0 +1,22 @@
+export type OutputFormat = 'svg' | 'png';
+/**
+ * Renders mermaid diagram text to an SVG string using
+ * the `beautiful-mermaid` library. No external process
+ * is spawned — everything runs in-process.
+ * @returns {string} The SVG markup as a string.
+ */
+export declare const renderMermaidSvg: (mermaidText: string) => string;
+/**
+ * Renders mermaid diagram text to an SVG file.
+ * Uses `beautiful-mermaid` in-process, then writes
+ * the result to a temp directory.
+ * @returns {Promise<string>} The file path of the generated SVG.
+ */
+export declare const renderMermaidToFile: (mermaidText: string) => Promise<string>;
+/**
+ * Renders mermaid diagram text to a PNG file.
+ * Uses `beautiful-mermaid` for SVG, then `@resvg/resvg-wasm`
+ * to convert SVG to PNG. Writes to a temp directory.
+ * @returns {Promise<string>} The file path of the generated PNG.
+ */
+export declare const renderMermaidToPng: (mermaidText: string) => Promise<string>;

package/dist/render-mermaid.js

@@ -0,0 +1,68 @@
+import { writeFile, mkdtemp } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { error } from '@vltpkg/error-cause';
+import { renderMermaidSVG } from 'beautiful-mermaid';
+/**
+ * Replace `#64;` with `@` for display rendering.
+ * Mermaid text uses `#64;` to avoid issues with `@` in
+ * GitHub/markdown parsers, but SVG/PNG should show `@`.
+ */
+const decodeForDisplay = (mermaidText) => mermaidText.replace(/#64;/g, '@');
+/**
+ * Renders mermaid diagram text to an SVG string using
+ * the `beautiful-mermaid` library. No external process
+ * is spawned — everything runs in-process.
+ * @returns {string} The SVG markup as a string.
+ */
+export const renderMermaidSvg = (mermaidText) => {
+    try {
+        return renderMermaidSVG(decodeForDisplay(mermaidText), {
+            bg: '#FFFFFF',
+            fg: '#27272A',
+            padding: 40,
+        });
+    }
+    catch (cause) {
+        throw error('Error rendering SVG', { cause });
+    }
+};
+/**
+ * Renders mermaid diagram text to an SVG file.
+ * Uses `beautiful-mermaid` in-process, then writes
+ * the result to a temp directory.
+ * @returns {Promise<string>} The file path of the generated SVG.
+ */
+export const renderMermaidToFile = async (mermaidText) => {
+    const svg = renderMermaidSvg(mermaidText);
+    const dir = await mkdtemp(join(tmpdir(), 'vlt-mermaid-'));
+    const outputFile = join(dir, 'graph.svg');
+    await writeFile(outputFile, svg);
+    return outputFile;
+};
+/**
+ * Renders mermaid diagram text to a PNG file.
+ * Uses `beautiful-mermaid` for SVG, then `@resvg/resvg-wasm`
+ * to convert SVG to PNG. Writes to a temp directory.
+ * @returns {Promise<string>} The file path of the generated PNG.
+ */
+export const renderMermaidToPng = async (mermaidText) => {
+    const svg = renderMermaidSvg(mermaidText);
+    const { Resvg, initWasm } = await import('@resvg/resvg-wasm');
+    const { readFile: rf } = await import('node:fs/promises');
+    const { createRequire: cr } = await import('node:module');
+    const wasmPath = cr(import.meta.url).resolve('@resvg/resvg-wasm/index_bg.wasm');
+    try {
+        await initWasm(await rf(wasmPath));
+    }
+    catch {
+        // WASM may already be initialized — ignore
+    }
+    const resvg = new Resvg(svg);
+    const pngData = resvg.render();
+    const pngBuffer = pngData.asPng();
+    const dir = await mkdtemp(join(tmpdir(), 'vlt-mermaid-'));
+    const outputFile = join(dir, 'graph.png');
+    await writeFile(outputFile, pngBuffer);
+    return outputFile;
+};

package/dist/view.d.ts

@@ -0,0 +1,29 @@
+import type { LoadedConfig } from './config/index.ts';
+export type ViewOptions = {
+    colors?: boolean;
+};
+/**
+ * The base class for all View classes
+ *
+ * Do not override the constructor, just provide start/done/error methods.
+ *
+ * These classes should be used as one or more of the exported views for
+ * commands that need to know when the processing starts, handle errors in
+ * various ways, etc. Fancy stuff.
+ *
+ * For simple use cases, usually better to create a {@link ViewFn} instead.
+ */
+export declare class ViewClass<T = unknown> {
+    options: ViewOptions;
+    config: LoadedConfig;
+    constructor(options: ViewOptions, config: LoadedConfig);
+    start(): void;
+    done(_result: T, _opts: {
+        time: number;
+    }): Promise<unknown>;
+    error(_err: unknown): void;
+}
+export type ViewFn<T = unknown> = (result: T, options: ViewOptions, conf: LoadedConfig) => unknown;
+export type View<T = unknown> = ViewFn<T> | typeof ViewClass<T>;
+export declare const isViewClass: <T = unknown>(view: View<T>) => view is typeof ViewClass<T>;
+export type Views<T = unknown> = View<T> | Record<string, View<T>>;

package/dist/view.js

@@ -0,0 +1,30 @@
+/**
+ * The base class for all View classes
+ *
+ * Do not override the constructor, just provide start/done/error methods.
+ *
+ * These classes should be used as one or more of the exported views for
+ * commands that need to know when the processing starts, handle errors in
+ * various ways, etc. Fancy stuff.
+ *
+ * For simple use cases, usually better to create a {@link ViewFn} instead.
+ */
+export class ViewClass {
+    options;
+    config;
+    constructor(options, config) {
+        this.options = options;
+        this.config = config;
+    }
+    // TODO: maybe have start() return a flag to say "i got this, do not
+    // run the command", for example to just open a web browser
+    // to the page relevant to a given thing, rather than computing it twice
+    start() { }
+    async done(_result, _opts) {
+        return;
+    }
+    error(_err) { }
+}
+export const isViewClass = (view) => typeof view === 'function' &&
+    'prototype' in view &&
+    view.prototype instanceof ViewClass;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vltpkg/cli-sdk",
   "description": "The source for the vlt CLI",
-  "version": "1.0.0-rc.22",
+  "version": "1.0.0-rc.24",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vltpkg/vltpkg.git",
@@ -13,30 +13,30 @@
   },
   "dependencies": {
     "@resvg/resvg-wasm": "^2.6.2",
-    "@vltpkg/config": "1.0.0-rc.22",
-    "@vltpkg/dep-id": "1.0.0-rc.22",
-    "@vltpkg/dot-prop": "1.0.0-rc.22",
-    "@vltpkg/error-cause": "1.0.0-rc.22",
-    "@vltpkg/git": "1.0.0-rc.22",
-    "@vltpkg/graph": "1.0.0-rc.22",
-    "@vltpkg/graph-run": "1.0.0-rc.22",
-    "@vltpkg/init": "1.0.0-rc.22",
-    "@vltpkg/output": "1.0.0-rc.22",
-    "@vltpkg/package-info": "1.0.0-rc.22",
-    "@vltpkg/package-json": "1.0.0-rc.22",
-    "@vltpkg/promise-spawn": "1.0.0-rc.22",
-    "@vltpkg/query": "1.0.0-rc.22",
-    "@vltpkg/registry-client": "1.0.0-rc.22",
-    "@vltpkg/rollback-remove": "1.0.0-rc.22",
-    "@vltpkg/run": "1.0.0-rc.22",
-    "@vltpkg/security-archive": "1.0.0-rc.22",
-    "@vltpkg/spec": "1.0.0-rc.22",
-    "@vltpkg/types": "1.0.0-rc.22",
-    "@vltpkg/url-open": "1.0.0-rc.22",
-    "@vltpkg/vlt-json": "1.0.0-rc.22",
-    "@vltpkg/vlx": "1.0.0-rc.22",
-    "@vltpkg/workspaces": "1.0.0-rc.22",
-    "@vltpkg/xdg": "1.0.0-rc.22",
+    "@vltpkg/config": "1.0.0-rc.24",
+    "@vltpkg/dep-id": "1.0.0-rc.24",
+    "@vltpkg/dot-prop": "1.0.0-rc.24",
+    "@vltpkg/error-cause": "1.0.0-rc.24",
+    "@vltpkg/git": "1.0.0-rc.24",
+    "@vltpkg/graph": "1.0.0-rc.24",
+    "@vltpkg/graph-run": "1.0.0-rc.24",
+    "@vltpkg/init": "1.0.0-rc.24",
+    "@vltpkg/output": "1.0.0-rc.24",
+    "@vltpkg/package-info": "1.0.0-rc.24",
+    "@vltpkg/package-json": "1.0.0-rc.24",
+    "@vltpkg/promise-spawn": "1.0.0-rc.24",
+    "@vltpkg/query": "1.0.0-rc.24",
+    "@vltpkg/registry-client": "1.0.0-rc.24",
+    "@vltpkg/rollback-remove": "1.0.0-rc.24",
+    "@vltpkg/run": "1.0.0-rc.24",
+    "@vltpkg/security-archive": "1.0.0-rc.24",
+    "@vltpkg/spec": "1.0.0-rc.24",
+    "@vltpkg/types": "1.0.0-rc.24",
+    "@vltpkg/url-open": "1.0.0-rc.24",
+    "@vltpkg/vlt-json": "1.0.0-rc.24",
+    "@vltpkg/vlx": "1.0.0-rc.24",
+    "@vltpkg/workspaces": "1.0.0-rc.24",
+    "@vltpkg/xdg": "1.0.0-rc.24",
     "ansi-to-pre": "^1.0.6",
     "beautiful-mermaid": "^1.1.3",
     "chalk": "^5.6.2",
@@ -87,28 +87,28 @@
     "extends": "../../tap-config.yaml"
   },
   "prettier": "../../.prettierrc.js",
-  "module": "./src/index.ts",
+  "module": "./dist/index.js",
   "type": "module",
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "import": {
-        "default": "./src/index.ts"
+        "default": "./dist/index.js"
       }
     },
     "./config": {
       "import": {
-        "default": "./src/config/index.ts"
+        "default": "./dist/config/index.js"
       }
     },
     "./definition": {
       "import": {
-        "default": "./src/config/definition.ts"
+        "default": "./dist/config/definition.js"
       }
     },
     "./view": {
       "import": {
-        "default": "./src/view.ts"
+        "default": "./dist/view.js"
       }
     }
   },