@vltpkg/cli-sdk 1.4.0 → 1.6.0

package/dist/shell-setup/index.js

@@ -0,0 +1,213 @@
+import { error } from '@vltpkg/error-cause';
+import { asError } from '@vltpkg/types';
+import { existsSync } from 'node:fs';
+import { chown, mkdir, realpath, writeFile } from 'node:fs/promises';
+import { basename, dirname, resolve } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { readGlobalState, updateGlobalState, writeFileAtomic, } from "../global-state.js";
+import { detectShell, fishPath, posixPath, prettyPath, shellPathCommand, } from "../shell.js";
+import { envFile, envFishFile, renderEnv, renderEnvFish, } from "./env.js";
+import { planEnvFile, planRcFile, rcFiles, renderBlock, } from "./posix.js";
+import { applyWindowsPath, planWindowsPath, userEnvLabel, } from "./windows.js";
+const posixShells = new Set([
+    'bash',
+    'zsh',
+    'fish',
+    'sh',
+]);
+/** whether `vlt setup --path` can edit config for `shell` */
+export const canSetupPath = (shell, platform = process.platform) => 
+// win32: the user Path reaches every shell
+platform === 'win32' || posixShells.has(shell);
+/** what adding `dir` to the `PATH` of new shells would change */
+export const planPathSetup = async (o) => {
+    const { globalDir, dir, shell } = o;
+    if ((o.platform ?? process.platform) === 'win32') {
+        const { env } = o;
+        const registry = await planWindowsPath(dir, { env });
+        return { globalDir, dir, shell, changes: [], registry, env };
+    }
+    const command = shellPathCommand(shell, dir, o);
+    if (!canSetupPath(shell, o.platform)) {
+        const what = shell === 'unknown' ? 'your shell' : shell;
+        throw error(`vlt setup --path doesn't support ${what} yet. Add it to your PATH yourself:\n  ${command}`, { code: 'ECONFIG', found: shell });
+    }
+    // env first: rc files point at it
+    const changes = [
+        await planEnvFile(envFile(globalDir), renderEnv(dir, o)),
+        await planEnvFile(envFishFile(globalDir), renderEnvFish(dir, o)),
+    ];
+    const posix = shell;
+    const block = renderBlock(posix, globalDir, o);
+    // links to one target: edit it once
+    const seen = new Set();
+    for (const f of rcFiles(posix, o)) {
+        const c = await planRcFile(f, block);
+        const real = await realpath(c.file).catch(() => c.file);
+        if (seen.has(real))
+            continue;
+        seen.add(real);
+        changes.push(c);
+    }
+    return { globalDir, dir, shell, changes };
+};
+export const pathSetupChanged = (plan) => plan.changes.some(c => c.action !== 'unchanged') ||
+    (!!plan.registry && plan.registry.action !== 'unchanged');
+export const pathSetupFiles = (plan) => {
+    const files = plan.changes.map(({ file, kind, action }) => ({ file, kind, action }));
+    const reg = plan.registry;
+    if (reg) {
+        files.push({
+            file: reg.key,
+            kind: 'registry',
+            action: reg.action,
+        });
+    }
+    return files;
+};
+/** rc files or the user Path, for display */
+export const rcList = (files, home) => files
+    .filter(f => f.kind !== 'env')
+    .map(f => f.kind === 'registry' ? userEnvLabel : prettyPath(f.file, home))
+    .join(', ');
+/** write the plan: env files, rc files, user Path, backed up */
+export const applyPathSetup = async (plan) => {
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupDir = resolve(plan.globalDir, 'backups');
+    const backups = [];
+    const backup = async (name, data, mode) => {
+        await mkdir(backupDir, { recursive: true });
+        const b = resolve(backupDir, `${name}.${stamp}.bak`);
+        await writeFile(b, data, { mode });
+        backups.push(b);
+    };
+    for (const c of plan.changes) {
+        if (c.action === 'unchanged')
+            continue;
+        if (c.previous !== undefined) {
+            await backup(basename(c.file).replace(/^\./, ''), c.previous, c.mode);
+        }
+        // sudo must not leave root-owned files in the home dir
+        const owner = process.getuid?.() === 0 ? c.owner : undefined;
+        // and the dirs mkdir makes
+        const own = [c.file];
+        let d = dirname(c.file);
+        while (owner && !existsSync(d)) {
+            own.push(d);
+            d = dirname(d);
+        }
+        await mkdir(dirname(c.file), { recursive: true });
+        await writeFileAtomic(c.file, c.content, c.mode);
+        if (owner) {
+            for (const f of own)
+                await chown(f, owner.uid, owner.gid);
+        }
+    }
+    const reg = plan.registry;
+    if (reg && reg.action !== 'unchanged') {
+        if (reg.previous !== undefined)
+            await backup('Path', reg.previous);
+        await applyWindowsPath(reg, { env: plan.env });
+    }
+    return {
+        dir: plan.dir,
+        shell: plan.shell,
+        files: pathSetupFiles(plan),
+        backups,
+    };
+};
+/** loads the env file into the current shell (win32: adds `dir`) */
+export const sourceCommand = (shell, globalDir, dir, o = {}) => 
+// no env file on win32
+(o.platform ?? process.platform) === 'win32' ?
+    shellPathCommand(shell, dir, o)
+    : shell === 'fish' ? `source ${fishPath(envFishFile(globalDir), o)}`
+        : shell === 'sh' ? `. ${posixPath(envFile(globalDir), o)}`
+            : `source ${posixPath(envFile(globalDir), o)}`;
+export const pathSetupLines = (r, source, home) => {
+    const lines = [
+        `✅ Added ${prettyPath(r.dir, home)} to your PATH in ${rcList(r.files, home)}`,
+        `   Open a new terminal${r.files.some(f => f.kind === 'registry') ? ' (restart editors like VS Code)' : ''}, or run: ${source}`,
+    ];
+    const [b] = r.backups;
+    if (b)
+        lines.push(`   Backups in ${prettyPath(dirname(b), home)}`);
+    return lines;
+};
+/** one trimmed answer */
+export const ask = async (question, { input = process.stdin, output = process.stdout, } = {}) => {
+    const rl = createInterface({ input, output });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+        input.pause();
+    }
+};
+/**
+ * After `install -g` linked into a dir not in the `PATH`: offer, once,
+ * in a terminal, to add it to the PATH. Never throws.
+ */
+export const offerPathSetup = async (g, o) => {
+    const { globalDir, input = process.stdin, output = process.stdout, env = process.env, platform, home, } = o;
+    if (o.noModifyPath || g.inPath)
+        return;
+    if (!g.bins.length && !g.conflicts.length)
+        return;
+    if (!input.isTTY || !output.isTTY || env.CI)
+        return;
+    if ((await readGlobalState(globalDir)).pathSetup === 'declined')
+        return;
+    const sh = { env, platform, home };
+    const shell = detectShell(env, platform);
+    const po = { ...sh, globalDir, dir: g.binDir, shell };
+    let plan;
+    try {
+        plan = await planPathSetup(po);
+    }
+    catch {
+        // the PATH warning has the manual line
+        return;
+    }
+    const rcs = rcList(pathSetupFiles(plan), home);
+    const source = sourceCommand(shell, globalDir, g.binDir, sh);
+    const write = (line) => output.write(line + '\n');
+    o.beforeOutput?.();
+    // blank line after the PATH warning
+    write('');
+    if (!pathSetupChanged(plan)) {
+        write(`ℹ️  It's already added in ${rcs}: open a new terminal, or run: ${source}`);
+        return;
+    }
+    if (!o.yes) {
+        let answer;
+        try {
+            answer = await ask(`Add it to ${rcs} now? (Y/n) `, {
+                input,
+                output,
+            });
+        }
+        catch {
+            return;
+        }
+        if (/^n/i.test(answer)) {
+            await updateGlobalState(globalDir, s => ({
+                ...s,
+                pathSetup: 'declined',
+            })).catch(() => { });
+            return;
+        }
+    }
+    try {
+        // rc files may have changed while asking
+        if (!o.yes)
+            plan = await planPathSetup(po);
+        const r = await applyPathSetup(plan);
+        for (const line of pathSetupLines(r, source, home))
+            write(line);
+    }
+    catch (er) {
+        write(`⚠️  Could not add it to your PATH: ${asError(er).message}`);
+    }
+};

package/dist/shell-setup/posix.d.ts

@@ -0,0 +1,36 @@
+import type { ShellOptions } from '../shell.ts';
+export type PosixShell = 'bash' | 'zsh' | 'fish' | 'sh';
+export declare const blockStart = "# vlt";
+export declare const blockEnd = "# vlt end";
+export type FileAction = 'create' | 'append' | 'replace' | 'unchanged';
+export type Owner = {
+    uid: number;
+    gid: number;
+};
+export type FileChange = {
+    /** file to write: the rc file, or its symlink target */
+    file: string;
+    kind: 'env' | 'rc';
+    action: FileAction;
+    /** bytes: rc files may not be UTF-8 */
+    content: Buffer;
+    /** rc content before an append/replace, backed up */
+    previous?: Buffer;
+    mode?: number;
+    /** of the rc file, or of the dir a new one goes in */
+    owner?: Owner;
+};
+/** rc files that load the env file in new `shell` sessions */
+export declare const rcFiles: (shell: PosixShell, { env, platform, home, }?: ShellOptions) => string[];
+/** the marked section loading the env file */
+export declare const renderBlock: (shell: PosixShell, globalDir: string, o?: ShellOptions) => string;
+/** the last complete vlt section in `content` */
+export declare const findBlock: (content: string) => {
+    start: number;
+    end: number;
+    text: string;
+} | undefined;
+/** env files are vlt's own: rewritten when different */
+export declare const planEnvFile: (file: string, text: string) => Promise<FileChange>;
+/** add or update the vlt section of an rc file */
+export declare const planRcFile: (file: string, block: string) => Promise<FileChange>;

package/dist/shell-setup/posix.js

@@ -0,0 +1,158 @@
+import { existsSync } from 'node:fs';
+import { lstat, readFile, realpath, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, resolve } from 'node:path';
+import { fishPath, posixPath } from "../shell.js";
+import { envFile, envFishFile } from "./env.js";
+export const blockStart = '# vlt';
+export const blockEnd = '# vlt end';
+const abs = (v) => v && isAbsolute(v) ? v : undefined;
+const isENOENT = (er) => er.code === 'ENOENT';
+const ownerOf = (st) => ({ uid: st.uid, gid: st.gid });
+// owner of the nearest existing dir
+const dirOwner = async (dir) => {
+    let st = await stat(dir).catch(() => undefined);
+    while (!st && dirname(dir) !== dir) {
+        dir = dirname(dir);
+        st = await stat(dir).catch(() => undefined);
+    }
+    return st && ownerOf(st);
+};
+// strings with one char per byte, so offsets are byte offsets
+const latin1 = (s) => Buffer.from(s).toString('latin1');
+const bytes = (s) => Buffer.from(s, 'latin1');
+/** rc files that load the env file in new `shell` sessions */
+export const rcFiles = (shell, { env = process.env, platform = process.platform, home = homedir(), } = {}) => {
+    const h = (f) => resolve(home, f);
+    switch (shell) {
+        case 'zsh':
+            // after path_helper, in every interactive zsh
+            return [resolve(abs(env.ZDOTDIR) ?? home, '.zshrc')];
+        case 'fish':
+            return [
+                resolve(abs(env.XDG_CONFIG_HOME) ?? h('.config'), 'fish/conf.d/vlt.fish'),
+            ];
+        case 'sh':
+            return [resolve(abs(env.ENV) ?? h('.profile'))];
+        case 'bash': {
+            const login = ['.bash_profile', '.bash_login'].map(h);
+            const list = [...login, h('.bashrc')].filter(f => existsSync(f));
+            // never create .bash_profile: it would shadow .profile.
+            // macOS terminals run login bash, which skips .bashrc
+            if (!list.length ||
+                (platform === 'darwin' && !login.some(f => list.includes(f)))) {
+                list.push(h('.profile'));
+            }
+            return list;
+        }
+    }
+};
+/** the marked section loading the env file */
+export const renderBlock = (shell, globalDir, o = {}) => {
+    let line;
+    if (shell === 'fish') {
+        const f = fishPath(envFishFile(globalDir), o);
+        line = `test -f ${f}; and source ${f}`;
+    }
+    else {
+        // status 0 when missing: `set -e` callers source rc files
+        const f = posixPath(envFile(globalDir), o);
+        line = `if [ -f ${f} ]; then . ${f}; fi`;
+    }
+    return `${blockStart}\n${line}\n${blockEnd}`;
+};
+const trimEnd = (line) => line.replace(/[\r \t]+$/, '');
+/** the last complete vlt section in `content` */
+export const findBlock = (content) => {
+    let start;
+    let found;
+    let offset = 0;
+    for (const raw of content.split('\n')) {
+        const line = trimEnd(raw);
+        if (line === blockStart)
+            start = offset;
+        else if (line === blockEnd && start !== undefined) {
+            found = { start, end: offset + line.length };
+            start = undefined;
+        }
+        offset += raw.length + 1;
+    }
+    if (!found)
+        return;
+    const text = content
+        .slice(found.start, found.end)
+        .split('\n')
+        .map(trimEnd)
+        .join('\n');
+    return { ...found, text };
+};
+/** env files are vlt's own: rewritten when different */
+export const planEnvFile = async (file, text) => {
+    const content = Buffer.from(text);
+    const previous = await readFile(file).catch((er) => {
+        if (isENOENT(er))
+            return undefined;
+        throw er;
+    });
+    return {
+        file,
+        kind: 'env',
+        content,
+        action: previous === undefined ? 'create'
+            : previous.equals(content) ? 'unchanged'
+                : 'replace',
+    };
+};
+/** add or update the vlt section of an rc file */
+export const planRcFile = async (file, block) => {
+    const lst = await lstat(file).catch((er) => {
+        if (isENOENT(er))
+            return undefined;
+        throw er;
+    });
+    if (!lst) {
+        return {
+            file,
+            kind: 'rc',
+            action: 'create',
+            content: Buffer.from(block + '\n'),
+            owner: await dirOwner(dirname(file)),
+        };
+    }
+    if (lst.isSymbolicLink()) {
+        // dotfile managers: edit the target, keep the link
+        file = await realpath(file);
+    }
+    const st = await stat(file);
+    const previous = await readFile(file);
+    const text = previous.toString('latin1');
+    const blk = latin1(block);
+    const base = {
+        file,
+        kind: 'rc',
+        mode: st.mode & 0o7777,
+        owner: ownerOf(st),
+    };
+    const b = findBlock(text);
+    if (!b) {
+        const sep = text === '' ? ''
+            : text.endsWith('\n') ? '\n'
+                : '\n\n';
+        return {
+            ...base,
+            action: 'append',
+            content: bytes(text + sep + blk + '\n'),
+            previous,
+        };
+    }
+    if (b.text === blk) {
+        return { ...base, action: 'unchanged', content: previous };
+    }
+    // the section is vlt's own: an old or edited one is replaced
+    return {
+        ...base,
+        action: 'replace',
+        content: bytes(text.slice(0, b.start) + blk + text.slice(b.end)),
+        previous,
+    };
+};

package/dist/shell-setup/windows.d.ts

@@ -0,0 +1,39 @@
+export declare const userEnvKey = "HKCU\\Environment";
+/** how the user Path is named in messages */
+export declare const userEnvLabel = "your Windows user environment";
+/** where users edit their Path by hand */
+export declare const editPathHint = "Start > \"Edit environment variables for your account\" > Path";
+export type WindowsOptions = {
+    env?: NodeJS.ProcessEnv;
+    /** key holding Path; tests use a scratch key */
+    key?: string;
+};
+/** REG_SZ, REG_EXPAND_SZ, else the raw .reg type (dword, hex(7), …) */
+export type RegValue = {
+    type: string;
+    data: string;
+};
+export type WindowsPathChange = {
+    key: string;
+    /** canonical dir, written as is */
+    dir: string;
+    action: 'create' | 'prepend' | 'unchanged';
+    /** Path before; undefined when not set */
+    previous?: string;
+    /** Path after */
+    data: string;
+};
+/** `name` in the first key of a `reg export` file */
+export declare const parseRegExport: (text: string, name: string) => RegValue | undefined;
+/** `%VAR%` expanded, names case-insensitive */
+export declare const expandEnv: (s: string, env?: NodeJS.ProcessEnv) => string;
+/** Path with `dir` first, unless already in it */
+export declare const addPathEntry: (value: RegValue | undefined, dir: string, env?: NodeJS.ProcessEnv) => Pick<WindowsPathChange, "action" | "previous" | "data">;
+/** the user Path value, undefined when not set */
+export declare const readUserPath: ({ env, key, }?: WindowsOptions) => Promise<RegValue | undefined>;
+/** what adding `dir` to the user Path would change */
+export declare const planWindowsPath: (dir: string, { env, key }?: WindowsOptions) => Promise<WindowsPathChange>;
+/** write the planned Path, then tell running programs */
+export declare const applyWindowsPath: (c: WindowsPathChange, { env }?: {
+    env?: NodeJS.ProcessEnv;
+}) => Promise<void>;

package/dist/shell-setup/windows.js

@@ -0,0 +1,151 @@
+import { error } from '@vltpkg/error-cause';
+import { promiseSpawn } from '@vltpkg/promise-spawn';
+import { asError } from '@vltpkg/types';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, win32 } from 'node:path';
+export const userEnvKey = 'HKCU\\Environment';
+/** how the user Path is named in messages */
+export const userEnvLabel = 'your Windows user environment';
+/** where users edit their Path by hand */
+export const editPathHint = 'Start > "Edit environment variables for your account" > Path';
+const refreshVar = 'VLT_PATH_REFRESH';
+const system32 = (env) => win32.join([env.SystemRoot, env.windir].find(d => d && win32.isAbsolute(d)) ?? 'C:\\Windows', 'System32');
+// absolute: never a reg.exe from the cwd
+const run = (env, exe, args) => promiseSpawn(win32.join(system32(env), exe), args, {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: true,
+});
+// reg's stderr, else the spawn error
+const detail = (er) => {
+    const e = asError(er);
+    const c = e.cause;
+    return (typeof c?.stderr === 'string' && c.stderr ? c.stderr
+        : c?.cause ? asError(c.cause).message
+            : e.message);
+};
+const fail = (what, key, why, hint, cause) => error(`Could not ${what} your user Path (${key}): ${why}\n  ${hint}`, {
+    code: 'ECONFIG',
+    cause,
+});
+const addIt = (dir) => `Add ${dir} yourself: ${editPathHint}`;
+const norm = (p, env) => win32
+    .normalize(expandEnv(p.trim().replace(/^"(.*)"$/, '$1'), env))
+    .replace(/[\\/]+$/, '')
+    .toLowerCase();
+// .reg strings escape \ and "
+const unesc = (s) => s.replace(/\\([\s\S])/g, '$1');
+/** `name` in the first key of a `reg export` file */
+export const parseRegExport = (text, name) => {
+    // hex values wrap as `,\` + newline + indent
+    const lines = text.replace(/,\\\r?\n */g, ',').split(/\r?\n/);
+    let inKey = false;
+    for (const line of lines) {
+        if (line.startsWith('[')) {
+            // subkeys follow
+            if (inKey)
+                return undefined;
+            inKey = true;
+            continue;
+        }
+        // [\s\S]: data may hold \r, U+2028, U+2029
+        const [, n = '', v = ''] = /^"((?:[^"\\]|\\[\s\S])*)"=([\s\S]*)$/.exec(line) ?? [];
+        if (!inKey || unesc(n).toLowerCase() !== name.toLowerCase()) {
+            continue;
+        }
+        const [, sz] = /^"((?:[^"\\]|\\[\s\S])*)"$/.exec(v) ?? [];
+        if (sz !== undefined)
+            return { type: 'REG_SZ', data: unesc(sz) };
+        const [, hex] = /^hex\(2\):([\da-f,]*)$/i.exec(v) ?? [];
+        if (hex !== undefined) {
+            const bytes = hex
+                .split(',')
+                .filter(Boolean)
+                .map(h => parseInt(h, 16));
+            return {
+                type: 'REG_EXPAND_SZ',
+                data: Buffer.from(bytes)
+                    .toString('utf16le')
+                    .replace(/\0+$/, ''),
+            };
+        }
+        return { type: v.replace(/:[\s\S]*$/, ''), data: '' };
+    }
+    return undefined;
+};
+/** `%VAR%` expanded, names case-insensitive */
+export const expandEnv = (s, env = process.env) => s.replace(/%([^%]+)%/g, (m, n) => Object.entries(env).find(([k]) => k.toLowerCase() === n.toLowerCase())?.[1] ?? m);
+/** Path with `dir` first, unless already in it */
+export const addPathEntry = (value, dir, env = process.env) => {
+    if (!value)
+        return { action: 'create', data: dir };
+    const previous = value.data;
+    const d = norm(dir, env);
+    if (previous.split(';').some(e => e.trim() && norm(e, env) === d)) {
+        return { action: 'unchanged', previous, data: previous };
+    }
+    return {
+        action: 'prepend',
+        previous,
+        data: previous ? `${dir};${previous}` : dir,
+    };
+};
+/** the user Path value, undefined when not set */
+export const readUserPath = async ({ env = process.env, key = userEnvKey, } = {}) => {
+    const d = await mkdtemp(join(tmpdir(), 'vlt-'));
+    const file = join(d, 'env.reg');
+    try {
+        // utf-16 file: reg query prints in the console code page
+        await run(env, 'reg.exe', ['export', key, file, '/y']);
+        const v = parseRegExport((await readFile(file)).toString('utf16le'), 'Path');
+        // lone surrogate or NUL: would not survive the write
+        if (v && /[\p{Cs}\0]/u.test(v.data)) {
+            throw new Error('it has characters vlt could not read');
+        }
+        return v;
+    }
+    finally {
+        // AV may hold the new file
+        await rm(d, {
+            recursive: true,
+            force: true,
+            maxRetries: 3,
+        }).catch(() => { });
+    }
+};
+/** what adding `dir` to the user Path would change */
+export const planWindowsPath = async (dir, { env = process.env, key = userEnvKey } = {}) => {
+    // would split or expand in Path
+    if (/[;%]/.test(dir)) {
+        throw fail('update', key, `the folder name has ";" or "%"`, 'Set --global-bin-dir to a folder without them');
+    }
+    const value = await readUserPath({ env, key }).catch((er) => {
+        throw fail('read', key, detail(er), addIt(dir), er);
+    });
+    if (value && !/^REG_(EXPAND_)?SZ$/.test(value.type)) {
+        throw fail('update', key, `unexpected value type ${value.type}`, addIt(dir));
+    }
+    return { key, dir, ...addPathEntry(value, dir, env) };
+};
+/** write the planned Path, then tell running programs */
+export const applyWindowsPath = async (c, { env = process.env } = {}) => {
+    await run(env, 'reg.exe', [
+        'add',
+        c.key,
+        '/v',
+        'Path',
+        '/t',
+        'REG_EXPAND_SZ',
+        '/d',
+        c.data,
+        '/f',
+    ]).catch((er) => {
+        throw fail('update', c.key, detail(er), addIt(c.dir), er);
+    });
+    if (c.key !== userEnvKey)
+        return;
+    // setx broadcasts WM_SETTINGCHANGE: new terminals see the new Path
+    await run(env, 'setx.exe', [refreshVar, '1'])
+        .then(() => run(env, 'reg.exe', ['delete', c.key, '/v', refreshVar, '/f']))
+        .catch(() => { });
+};

package/dist/shell.d.ts

@@ -0,0 +1,18 @@
+export type Shell = 'bash' | 'zsh' | 'fish' | 'sh' | 'nu' | 'pwsh' | 'cmd' | 'unknown';
+export type ShellOptions = {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    home?: string;
+};
+/** `~/x` for a path under the home dir */
+export declare const prettyPath: (path: string, home?: string, win32?: boolean) => string;
+/** the user's shell, from `SHELL`, or a guess on win32 */
+export declare const detectShell: (env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform) => Shell;
+/** `dir` double-quoted for a POSIX shell, `$HOME` late-bound */
+export declare const posixPath: (dir: string, o?: ShellOptions) => string;
+/** `dir` double-quoted for fish, `$HOME` late-bound */
+export declare const fishPath: (dir: string, o?: ShellOptions) => string;
+/** the line that adds `dir` to the `PATH` in `shell` */
+export declare const shellPathCommand: (shell: Shell, dir: string, o?: ShellOptions) => string;
+/** rc file to add the `PATH` line to, for display */
+export declare const shellRcFile: (shell: Shell, o?: ShellOptions) => string | undefined;