@speedkit/cli 4.17.1 → 4.19.0

package/dist/services/customer-config/templates/config_SpeedKit.js.hbs

@@ -137,6 +137,17 @@ import { ShopifyPlugin } from "speed-kit-config/ShopifyPlugin";
     split: CURRENT_HOST_CONFIG.split,
     splitTestId: CURRENT_HOST_CONFIG.splitTestId,
     disabled: !CURRENT_HOST_CONFIG.enabled,
+    // TODO: walk the live checkout + login flows and pin exact prefixes (SSO/PSP returns, separate reg pages). See /disabled-scopes.
+    disabledScopes: [
+      "/cart",
+      "/checkout",
+{{#if isShopify}}
+      "/account", // login/register/recover/orders
+      "/services/login_with_shop", // Shop Pay auto-login transfer (platform route, all locales)
+{{else}}
+      "/login",
+{{/if}}
+    ],
     enabledSites: [
       {
         pathname: [

package/dist/services/setup/browser/browser-detector.d.ts

@@ -0,0 +1,27 @@
+import { Platform } from "../os/tool-registry.js";
+export type BrowserSource = "system" | "puppeteer";
+export interface BrowserOption {
+    /** stable id used as the select value */
+    id: string;
+    /** display name incl. version/build when known */
+    name: string;
+    executablePath: string;
+    source: BrowserSource;
+    /** puppeteer buildId, only for puppeteer-managed browsers */
+    buildId?: string;
+    /** puppeteer Browser id (e.g. "chrome"), only for puppeteer-managed */
+    browser?: string;
+}
+export declare class BrowserDetector {
+    private readonly platform;
+    private readonly home;
+    private readonly cachePath;
+    private readonly env;
+    constructor(platform: Platform, home: string, cachePath: string, env?: NodeJS.ProcessEnv);
+    /** Browsers installed system-wide, discovered via the OS tool registry. */
+    detectSystemBrowsers(): BrowserOption[];
+    /** Browsers previously downloaded into the puppeteer cache. */
+    detectPuppeteerBrowsers(): BrowserOption[];
+    /** All detected browsers, puppeteer-managed first then system. */
+    detectAll(): BrowserOption[];
+}

package/dist/services/setup/browser/browser-detector.js

@@ -0,0 +1,47 @@
+import { Cache } from "@puppeteer/browsers";
+import { BROWSERS } from "../os/tool-registry.js";
+import { detectTools } from "../os/detector-helper.js";
+export class BrowserDetector {
+    platform;
+    home;
+    cachePath;
+    env;
+    constructor(platform, home, cachePath, env = process.env) {
+        this.platform = platform;
+        this.home = home;
+        this.cachePath = cachePath;
+        this.env = env;
+    }
+    /** Browsers installed system-wide, discovered via the OS tool registry. */
+    detectSystemBrowsers() {
+        return detectTools(BROWSERS, this.platform, this.home, this.env).map((tool) => ({
+            id: `system:${tool.id}`,
+            name: tool.name,
+            executablePath: tool.executablePath,
+            source: "system",
+        }));
+    }
+    /** Browsers previously downloaded into the puppeteer cache. */
+    detectPuppeteerBrowsers() {
+        const cache = new Cache(this.cachePath);
+        let installed;
+        try {
+            installed = cache.getInstalledBrowsers();
+        }
+        catch {
+            return [];
+        }
+        return installed.map((browser) => ({
+            id: `puppeteer:${browser.browser}@${browser.buildId}`,
+            name: `${browser.browser} ${browser.buildId} (puppeteer)`,
+            executablePath: browser.executablePath,
+            source: "puppeteer",
+            buildId: browser.buildId,
+            browser: browser.browser,
+        }));
+    }
+    /** All detected browsers, puppeteer-managed first then system. */
+    detectAll() {
+        return [...this.detectPuppeteerBrowsers(), ...this.detectSystemBrowsers()];
+    }
+}

package/dist/services/setup/browser/browser-manager.d.ts

@@ -0,0 +1,43 @@
+import { InstalledBrowser } from "@puppeteer/browsers";
+import { CliServiceInterface } from "../../cli/index.js";
+export type BrowserChannel = "stable" | "experimental";
+export interface InstalledBrowserInfo {
+    browser: string;
+    buildId: string;
+    executablePath: string;
+}
+/**
+ * Thin wrapper around `@puppeteer/browsers` for installing, listing and
+ * removing Chrome builds. Kept UI-agnostic apart from an optional progress
+ * spinner, so it can be reused by the wizard and the `sk browser` commands.
+ */
+export declare class BrowserManager {
+    private readonly cacheDir;
+    private readonly cli?;
+    constructor(cacheDir: string, cli?: CliServiceInterface);
+    /**
+     * Resolves the concrete buildId for a channel (e.g. "stable" -> "139.0...").
+     */
+    resolveBuildId(channel: BrowserChannel): Promise<string>;
+    /**
+     * Installs Chrome for the given channel and returns the installed build.
+     */
+    installChannel(channel: BrowserChannel): Promise<InstalledBrowser>;
+    /**
+     * Installs a specific Chrome buildId and returns the installed build.
+     */
+    installBuildId(buildId: string): Promise<InstalledBrowser>;
+    /**
+     * Lists all browsers currently present in the puppeteer cache.
+     */
+    list(): InstalledBrowserInfo[];
+    /**
+     * Removes a single browser build from the puppeteer cache.
+     */
+    remove(browser: string, buildId: string): Promise<void>;
+    /**
+     * Removes all browser builds from the puppeteer cache.
+     */
+    removeAll(): Promise<void>;
+    private getPlatform;
+}

package/dist/services/setup/browser/browser-manager.js

@@ -0,0 +1,101 @@
+import { Browser, detectBrowserPlatform, install, resolveBuildId, uninstall, Cache, } from "@puppeteer/browsers";
+/**
+ * Maps the wizard's user-facing channel to a puppeteer build tag.
+ * "experimental" follows Chrome Canary; "stable" follows the stable channel.
+ */
+function channelToTag(channel) {
+    return channel === "experimental" ? "canary" : "stable";
+}
+/**
+ * Thin wrapper around `@puppeteer/browsers` for installing, listing and
+ * removing Chrome builds. Kept UI-agnostic apart from an optional progress
+ * spinner, so it can be reused by the wizard and the `sk browser` commands.
+ */
+export class BrowserManager {
+    cacheDir;
+    cli;
+    constructor(cacheDir, cli) {
+        this.cacheDir = cacheDir;
+        this.cli = cli;
+    }
+    /**
+     * Resolves the concrete buildId for a channel (e.g. "stable" -> "139.0...").
+     */
+    async resolveBuildId(channel) {
+        const platform = this.getPlatform();
+        return resolveBuildId(Browser.CHROME, platform, channelToTag(channel));
+    }
+    /**
+     * Installs Chrome for the given channel and returns the installed build.
+     */
+    async installChannel(channel) {
+        const buildId = await this.resolveBuildId(channel);
+        return this.installBuildId(buildId);
+    }
+    /**
+     * Installs a specific Chrome buildId and returns the installed build.
+     */
+    async installBuildId(buildId) {
+        const platform = this.getPlatform();
+        const actionName = "browser-install";
+        this.cli?.startAction(actionName, `Downloading Chrome ${buildId}…`);
+        try {
+            const installed = await install({
+                browser: Browser.CHROME,
+                buildId,
+                cacheDir: this.cacheDir,
+                platform,
+            });
+            this.cli?.successAction(actionName, `Installed Chrome ${buildId}`);
+            return installed;
+        }
+        catch (error) {
+            this.cli?.failAction(actionName, `Failed to install Chrome ${buildId}: ${error?.message ?? error}`);
+            throw error;
+        }
+    }
+    /**
+     * Lists all browsers currently present in the puppeteer cache.
+     */
+    list() {
+        const cache = new Cache(this.cacheDir);
+        let installed;
+        try {
+            installed = cache.getInstalledBrowsers();
+        }
+        catch {
+            return [];
+        }
+        return installed.map((browser) => ({
+            browser: browser.browser,
+            buildId: browser.buildId,
+            executablePath: browser.executablePath,
+        }));
+    }
+    /**
+     * Removes a single browser build from the puppeteer cache.
+     */
+    async remove(browser, buildId) {
+        await uninstall({
+            browser: browser,
+            buildId,
+            cacheDir: this.cacheDir,
+            platform: this.getPlatform(),
+        });
+    }
+    /**
+     * Removes all browser builds from the puppeteer cache.
+     */
+    async removeAll() {
+        for (const installed of this.list()) {
+            await this.remove(installed.browser, installed.buildId);
+        }
+    }
+    getPlatform() {
+        const platform = detectBrowserPlatform();
+        if (!platform) {
+            throw new Error("Unable to detect browser platform for this OS");
+        }
+        return platform;
+    }
+}

package/dist/services/setup/browser/browser-setup-service.d.ts

@@ -0,0 +1,28 @@
+import { CliServiceInterface } from "../../cli/index.js";
+import { CliConfig, UserCliConfig } from "../../../helpers/cli-config.js";
+import { BrowserDetector } from "./browser-detector.js";
+import { BrowserManager } from "./browser-manager.js";
+export declare class BrowserSetupService {
+    private readonly cli;
+    private readonly cliConfig;
+    private readonly userConfig;
+    private readonly detector;
+    private readonly manager;
+    constructor(cli: CliServiceInterface, cliConfig: CliConfig, userConfig: UserCliConfig, detector: BrowserDetector, manager: BrowserManager);
+    /**
+     * Interactive browser selection: pick a detected browser or download one via
+     * puppeteer, then persist the choice.
+     */
+    run(): Promise<void>;
+    /**
+     * Checks — at most once per reminder interval — whether the puppeteer-managed
+     * browser has a newer build and offers to update it. Only applies to browsers
+     * we installed (i.e. a channel is configured). Safe to call on every command;
+     * callers must ensure the session is interactive first.
+     */
+    remindIfDue(): Promise<void>;
+    private installAndPersist;
+    private askReminderDays;
+    private isReminderDue;
+    private nowIso;
+}

package/dist/services/setup/browser/browser-setup-service.js

@@ -0,0 +1,136 @@
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+export class BrowserSetupService {
+    cli;
+    cliConfig;
+    userConfig;
+    detector;
+    manager;
+    constructor(cli, cliConfig, userConfig, detector, manager) {
+        this.cli = cli;
+        this.cliConfig = cliConfig;
+        this.userConfig = userConfig;
+        this.detector = detector;
+        this.manager = manager;
+    }
+    /**
+     * Interactive browser selection: pick a detected browser or download one via
+     * puppeteer, then persist the choice.
+     */
+    async run() {
+        const detected = this.detector.detectAll();
+        const choices = [
+            ...detected.map((browser) => ({
+                name: `${browser.name}  ${this.cli.style.grey(browser.executablePath)}`,
+                value: browser.id,
+            })),
+            {
+                name: "Download Chrome (stable) via puppeteer",
+                value: "install:stable",
+            },
+            {
+                name: "Download Chrome (experimental / canary) via puppeteer",
+                value: "install:experimental",
+            },
+        ];
+        const currentDefault = detected.find((browser) => browser.executablePath === this.userConfig.chromePath)?.id;
+        const selected = await this.cli.select("Which browser should Speed Kit use?", choices, currentDefault);
+        if (selected.startsWith("install:")) {
+            const channel = selected.slice("install:".length);
+            await this.installAndPersist(channel);
+            return;
+        }
+        const chosen = detected.find((browser) => browser.id === selected);
+        if (!chosen) {
+            this.cli.writeError("Selected browser could not be resolved.");
+            return;
+        }
+        this.cliConfig.save({
+            chromePath: chosen.executablePath,
+            // a manually selected browser is not update-managed by the wizard, so
+            // clear the channel to disable the update reminder for it
+            browserChannel: "",
+            browserBuildId: chosen.buildId ?? "",
+        });
+        this.cli.writeSuccess(`Using ${chosen.name} (${chosen.executablePath}).`);
+    }
+    /**
+     * Checks — at most once per reminder interval — whether the puppeteer-managed
+     * browser has a newer build and offers to update it. Only applies to browsers
+     * we installed (i.e. a channel is configured). Safe to call on every command;
+     * callers must ensure the session is interactive first.
+     */
+    async remindIfDue() {
+        const channel = this.userConfig.browserChannel;
+        if (channel !== "stable" && channel !== "experimental") {
+            return;
+        }
+        if (!this.isReminderDue()) {
+            return;
+        }
+        let latestBuildId;
+        try {
+            latestBuildId = await this.manager.resolveBuildId(channel);
+        }
+        catch {
+            // offline / resolution failure: try again next interval
+            return;
+        }
+        // stamp the check regardless so we don't re-check until the next interval
+        this.cliConfig.save({ lastBrowserUpdateCheck: this.nowIso() });
+        if (latestBuildId === this.userConfig.browserBuildId) {
+            return;
+        }
+        if (this.userConfig.browserAutoUpdate) {
+            await this.installAndPersist(channel);
+            return;
+        }
+        const update = await this.cli.confirm(`A newer Chrome ${channel} build (${latestBuildId}) is available. Update now?`, true);
+        if (update) {
+            await this.installAndPersist(channel);
+            return;
+        }
+        await this.askReminderDays();
+    }
+    async installAndPersist(channel) {
+        const installed = await this.manager.installChannel(channel);
+        this.cliConfig.save({
+            chromePath: installed.executablePath,
+            browserChannel: channel,
+            browserBuildId: installed.buildId,
+            lastBrowserUpdateCheck: this.nowIso(),
+        });
+        const autoUpdate = await this.cli.confirm("Automatically update the browser when a newer build is available?", this.userConfig.browserAutoUpdate);
+        this.cliConfig.save({ browserAutoUpdate: autoUpdate });
+        if (!autoUpdate) {
+            await this.askReminderDays();
+        }
+    }
+    async askReminderDays() {
+        const answer = await this.cli.prompt("Remind me to check for browser updates in how many days?", {
+            defaultAnswer: String(this.userConfig.updateReminderDays || 3),
+            validator: (value) => /^\d+$/.test(value.trim()) ? "" : "Enter a whole number of days",
+        });
+        const days = Number.parseInt(answer, 10);
+        if (!Number.isNaN(days) && days > 0) {
+            this.cliConfig.save({
+                updateReminderDays: days,
+                lastBrowserUpdateCheck: this.nowIso(),
+            });
+        }
+    }
+    isReminderDue() {
+        const days = this.userConfig.updateReminderDays || 3;
+        const last = this.userConfig.lastBrowserUpdateCheck;
+        if (!last) {
+            return true;
+        }
+        const lastMs = new Date(last).getTime();
+        if (Number.isNaN(lastMs)) {
+            return true;
+        }
+        return (Date.now() - lastMs) / MS_PER_DAY >= days;
+    }
+    nowIso() {
+        return new Date().toISOString();
+    }
+}

package/dist/services/setup/difftool/difftool-detector.d.ts

@@ -0,0 +1,14 @@
+import { Platform } from "../os/tool-registry.js";
+export interface DetectedEditor {
+    id: string;
+    name: string;
+    executablePath: string;
+    diffExecTemplate: string;
+}
+export declare class DiffToolDetector {
+    private readonly platform;
+    private readonly home;
+    private readonly env;
+    constructor(platform: Platform, home: string, env?: NodeJS.ProcessEnv);
+    detect(): DetectedEditor[];
+}

package/dist/services/setup/difftool/difftool-detector.js

@@ -0,0 +1,27 @@
+import { EDITORS } from "../os/tool-registry.js";
+import { detectTool } from "../os/detector-helper.js";
+export class DiffToolDetector {
+    platform;
+    home;
+    env;
+    constructor(platform, home, env = process.env) {
+        this.platform = platform;
+        this.home = home;
+        this.env = env;
+    }
+    detect() {
+        const detected = [];
+        for (const editor of EDITORS) {
+            const result = detectTool(editor, this.platform, this.home, this.env);
+            if (result) {
+                detected.push({
+                    id: editor.id,
+                    name: editor.name,
+                    executablePath: result.executablePath,
+                    diffExecTemplate: editor.diffExecTemplate,
+                });
+            }
+        }
+        return detected;
+    }
+}

package/dist/services/setup/difftool/difftool-setup-service.d.ts

@@ -0,0 +1,15 @@
+import { CliServiceInterface } from "../../cli/index.js";
+import { CliConfig, UserCliConfig } from "../../../helpers/cli-config.js";
+import { DiffToolDetector } from "./difftool-detector.js";
+export declare class DiffToolSetupService {
+    private readonly cli;
+    private readonly cliConfig;
+    private readonly userConfig;
+    private readonly detector;
+    constructor(cli: CliServiceInterface, cliConfig: CliConfig, userConfig: UserCliConfig, detector: DiffToolDetector);
+    /**
+     * Detects installed editors/diff tools, lets the user pick one, and persists
+     * it as diffExec + diffExecTemplate + diffTool.
+     */
+    run(): Promise<void>;
+}

package/dist/services/setup/difftool/difftool-setup-service.js

@@ -0,0 +1,46 @@
+export class DiffToolSetupService {
+    cli;
+    cliConfig;
+    userConfig;
+    detector;
+    constructor(cli, cliConfig, userConfig, detector) {
+        this.cli = cli;
+        this.cliConfig = cliConfig;
+        this.userConfig = userConfig;
+        this.detector = detector;
+    }
+    /**
+     * Detects installed editors/diff tools, lets the user pick one, and persists
+     * it as diffExec + diffExecTemplate + diffTool.
+     */
+    async run() {
+        const detected = this.detector.detect();
+        if (detected.length === 0) {
+            this.cli.writeWarning("No supported diff tool (IntelliJ / VS Code family) was found. " +
+                "You can set diffExec manually in the config later.");
+            return;
+        }
+        const choices = [
+            ...detected.map((editor) => ({
+                name: `${editor.name}  ${this.cli.style.grey(editor.executablePath)}`,
+                value: editor.id,
+            })),
+            { name: "Skip — configure manually later", value: "skip" },
+        ];
+        const selected = await this.cli.select("Which diff tool should Speed Kit use?", choices, this.userConfig.diffTool || undefined);
+        if (selected === "skip") {
+            return;
+        }
+        const chosen = detected.find((editor) => editor.id === selected);
+        if (!chosen) {
+            this.cli.writeError("Selected diff tool could not be resolved.");
+            return;
+        }
+        this.cliConfig.save({
+            diffTool: chosen.id,
+            diffExec: chosen.executablePath,
+            diffExecTemplate: chosen.diffExecTemplate,
+        });
+        this.cli.writeSuccess(`Using ${chosen.name} for diffs.`);
+    }
+}

package/dist/services/setup/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./setup-context.js";
+export * from "./setup-service.js";
+export * from "./setup-service-factory.js";
+export * from "./browser/browser-detector.js";
+export * from "./browser/browser-manager.js";
+export * from "./browser/browser-setup-service.js";
+export * from "./difftool/difftool-detector.js";
+export * from "./difftool/difftool-setup-service.js";
+export * from "./os/tool-registry.js";
+export * from "./os/detector-helper.js";

package/dist/services/setup/index.js

@@ -0,0 +1,10 @@
+export * from "./setup-context.js";
+export * from "./setup-service.js";
+export * from "./setup-service-factory.js";
+export * from "./browser/browser-detector.js";
+export * from "./browser/browser-manager.js";
+export * from "./browser/browser-setup-service.js";
+export * from "./difftool/difftool-detector.js";
+export * from "./difftool/difftool-setup-service.js";
+export * from "./os/tool-registry.js";
+export * from "./os/detector-helper.js";

package/dist/services/setup/os/detector-helper.d.ts

@@ -0,0 +1,29 @@
+import { DetectableTool, Platform } from "./tool-registry.js";
+/**
+ * Result of locating a tool on the current system.
+ */
+export interface DetectedTool {
+    id: string;
+    name: string;
+    /** absolute path to the executable/launcher that was found */
+    executablePath: string;
+}
+/**
+ * Resolves a launcher command on PATH, returning its absolute path or null.
+ * Uses `where` on Windows and `which` elsewhere.
+ */
+export declare function resolveOnPath(command: string, platform: Platform): string | null;
+/**
+ * Returns the first candidate path that exists on disk, after expanding
+ * `~`/`%VAR%` tokens, or null when none exist.
+ */
+export declare function findExistingCandidatePath(candidates: string[], home: string, env?: NodeJS.ProcessEnv): string | null;
+/**
+ * Detects a single tool: first via its known candidate paths (preferred, as it
+ * yields an absolute executable), then falling back to a PATH lookup.
+ */
+export declare function detectTool(tool: DetectableTool, platform: Platform, home: string, env?: NodeJS.ProcessEnv): DetectedTool | null;
+/**
+ * Detects every tool in the list, dropping the ones that are not installed.
+ */
+export declare function detectTools(tools: DetectableTool[], platform: Platform, home: string, env?: NodeJS.ProcessEnv): DetectedTool[];

package/dist/services/setup/os/detector-helper.js

@@ -0,0 +1,65 @@
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { expandCandidatePath, } from "./tool-registry.js";
+/**
+ * Resolves a launcher command on PATH, returning its absolute path or null.
+ * Uses `where` on Windows and `which` elsewhere.
+ */
+export function resolveOnPath(command, platform) {
+    const finder = platform === "win32" ? "where" : "which";
+    try {
+        const output = execFileSync(finder, [command], {
+            stdio: ["ignore", "pipe", "ignore"],
+        })
+            .toString()
+            .trim();
+        // `where` may return multiple lines; take the first hit
+        const first = output.split(/\r?\n/).find((line) => line.trim().length > 0);
+        if (first && existsSync(first.trim())) {
+            return first.trim();
+        }
+    }
+    catch {
+        // not found on PATH
+    }
+    return null;
+}
+/**
+ * Returns the first candidate path that exists on disk, after expanding
+ * `~`/`%VAR%` tokens, or null when none exist.
+ */
+export function findExistingCandidatePath(candidates, home, env = process.env) {
+    for (const candidate of candidates) {
+        const expanded = expandCandidatePath(candidate, home, env);
+        if (existsSync(expanded)) {
+            return expanded;
+        }
+    }
+    return null;
+}
+/**
+ * Detects a single tool: first via its known candidate paths (preferred, as it
+ * yields an absolute executable), then falling back to a PATH lookup.
+ */
+export function detectTool(tool, platform, home, env = process.env) {
+    const candidatePaths = tool.paths[platform] ?? [];
+    const fromPath = findExistingCandidatePath(candidatePaths, home, env);
+    if (fromPath) {
+        return { id: tool.id, name: tool.name, executablePath: fromPath };
+    }
+    for (const command of tool.commands) {
+        const resolved = resolveOnPath(command, platform);
+        if (resolved) {
+            return { id: tool.id, name: tool.name, executablePath: resolved };
+        }
+    }
+    return null;
+}
+/**
+ * Detects every tool in the list, dropping the ones that are not installed.
+ */
+export function detectTools(tools, platform, home, env = process.env) {
+    return tools
+        .map((tool) => detectTool(tool, platform, home, env))
+        .filter((result) => result !== null);
+}

package/dist/services/setup/os/tool-registry.d.ts

@@ -0,0 +1,38 @@
+/**
+ * OS-specific registry of the browsers and diff/editor tools the first-run
+ * wizard knows how to detect. Detection strategies differ per platform, so the
+ * candidate executable paths and PATH launcher names are grouped by platform.
+ *
+ * This module holds only data + pure helpers; the actual filesystem probing
+ * lives in the browser/diff-tool detectors.
+ */
+export type Platform = "darwin" | "win32" | "linux";
+export interface DetectableTool {
+    /** stable identifier persisted to config, e.g. "chrome", "code" */
+    id: string;
+    /** human-readable name shown in prompts */
+    name: string;
+    /** launcher names to resolve on PATH (`which`/`where`) */
+    commands: string[];
+    /** absolute candidate paths per platform (support `~` and `%VAR%` tokens) */
+    paths: Partial<Record<Platform, string[]>>;
+}
+export interface DetectableEditor extends DetectableTool {
+    /**
+     * diff-service template for this tool, using the `$exec`/`$file1`/`$file2`
+     * placeholders understood by DiffService.
+     */
+    diffExecTemplate: string;
+}
+export declare const BROWSERS: DetectableTool[];
+export declare const EDITORS: DetectableEditor[];
+/**
+ * Normalizes an unknown platform string into one of the supported platforms.
+ * Falls back to "linux" for the various *nix variants Node may report.
+ */
+export declare function normalizePlatform(platform: string): Platform;
+/**
+ * Expands `~` (home) and Windows `%VAR%` tokens in a candidate path. Unknown
+ * `%VAR%` tokens are left untouched so a later existence check simply misses.
+ */
+export declare function expandCandidatePath(raw: string, home: string, env?: NodeJS.ProcessEnv): string;