@hades200082/envsync 0.0.2

package/dist/src/env.js

@@ -0,0 +1,183 @@
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { log } from "./log.js";
+const BEGIN = "__ENVSYNC_ENV_BEGIN__";
+const END = "__ENVSYNC_ENV_END__";
+/**
+ * Re-read the environment the way a fresh terminal would see it and merge
+ * it into this process, so a tool installed by one step is on PATH for the next.
+ *
+ * Windows: PATH and other variables come from the registry (Machine + User).
+ * Unix: a login shell (interactive first, so ~/.bashrc counts) dumps its env.
+ */
+export async function refreshEnvironment(platform, env = process.env) {
+    const fresh = platform.os === "windows" ? await readWindowsEnvironment() : await readUnixEnvironment(env);
+    if (!fresh) {
+        log.debug("environment refresh: could not read a fresh environment, keeping the current one");
+        return false;
+    }
+    const added = mergeEnvironment(env, fresh, platform.os === "windows");
+    if (added.length)
+        log.debug(`environment refresh: new PATH entries: ${added.join(path.delimiter)}`);
+    else
+        log.debug("environment refresh: PATH unchanged");
+    return true;
+}
+/**
+ * Merge `fresh` into `target`. PATH becomes the fresh PATH followed by any
+ * entries only the current process had. Other variables are only added when
+ * missing, so nothing the user set for this run is overwritten.
+ * Returns the PATH entries that were new.
+ *
+ * `windows` selects the PATH rules: `;` as the separator, case-insensitive
+ * names and entries. It is a parameter rather than read from the host so
+ * the Windows rules can be tested on any OS.
+ */
+export function mergeEnvironment(target, fresh, windows) {
+    const caseInsensitive = windows;
+    const delimiter = windows ? ";" : ":";
+    const pathKey = findKey(target, "PATH", caseInsensitive) ?? "PATH";
+    const freshPathKey = findKey(fresh, "PATH", caseInsensitive);
+    const currentEntries = splitPath(target[pathKey] ?? "", delimiter);
+    const freshEntries = freshPathKey ? splitPath(fresh[freshPathKey] ?? "", delimiter) : [];
+    const norm = (p) => (caseInsensitive ? p.toLowerCase() : p).replace(/[\\/]+$/, "");
+    const seen = new Set();
+    const merged = [];
+    for (const entry of [...freshEntries, ...currentEntries]) {
+        const key = norm(entry);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(entry);
+    }
+    const currentSet = new Set(currentEntries.map(norm));
+    const added = [];
+    for (const entry of freshEntries) {
+        if (!currentSet.has(norm(entry)) && !added.includes(entry))
+            added.push(entry);
+    }
+    target[pathKey] = merged.join(delimiter);
+    for (const [key, value] of Object.entries(fresh)) {
+        if (key.toUpperCase() === "PATH")
+            continue;
+        if (findKey(target, key, caseInsensitive) === undefined)
+            target[key] = value;
+    }
+    return added;
+}
+function splitPath(value, delimiter) {
+    return value
+        .split(delimiter)
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+function findKey(obj, key, caseInsensitive) {
+    if (!caseInsensitive)
+        return key in obj ? key : undefined;
+    const upper = key.toUpperCase();
+    return Object.keys(obj).find((k) => k.toUpperCase() === upper);
+}
+async function readWindowsEnvironment() {
+    // Machine first, then User, matching how Windows builds PATH for a new process.
+    const script = [
+        "$m = [Environment]::GetEnvironmentVariables('Machine')",
+        "$u = [Environment]::GetEnvironmentVariables('User')",
+        "$out = @{}",
+        "foreach ($k in $m.Keys) { $out[$k] = [string]$m[$k] }",
+        "foreach ($k in $u.Keys) { if ($k -ieq 'Path') { $out['Path'] = ($out['Path'] + ';' + $u[$k]) } else { $out[$k] = [string]$u[$k] } }",
+        `Write-Output '${BEGIN}'`,
+        "Write-Output ($out | ConvertTo-Json -Compress)",
+        `Write-Output '${END}'`,
+    ].join("\n");
+    const encoded = Buffer.from(script, "utf16le").toString("base64");
+    const systemRoot = process.env.SystemRoot ?? process.env.windir ?? "C:\\Windows";
+    const shells = ["pwsh", "powershell.exe", `${systemRoot}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`];
+    for (const shell of shells) {
+        const out = await capture(shell, ["-NoLogo", "-NoProfile", "-NonInteractive", "-EncodedCommand", encoded], 15000);
+        const parsed = extractJson(out);
+        if (parsed)
+            return expandWindowsVariables(parsed);
+    }
+    return undefined;
+}
+/** Registry values can hold %SystemRoot% style references; expand them. */
+function expandWindowsVariables(vars) {
+    const lookup = (name) => {
+        const upper = name.toUpperCase();
+        const key = Object.keys(vars).find((k) => k.toUpperCase() === upper);
+        if (key !== undefined)
+            return vars[key];
+        const envKey = Object.keys(process.env).find((k) => k.toUpperCase() === upper);
+        return envKey !== undefined ? process.env[envKey] : undefined;
+    };
+    const out = {};
+    for (const [k, v] of Object.entries(vars)) {
+        out[k] = v.replace(/%([^%]+)%/g, (m, name) => lookup(name) ?? m);
+    }
+    return out;
+}
+async function readUnixEnvironment(env) {
+    const shell = env.SHELL && env.SHELL.length > 0 ? env.SHELL : "/bin/sh";
+    const dump = `${quote(process.execPath)} -e 'process.stdout.write("${BEGIN}"+JSON.stringify(process.env)+"${END}")'`;
+    // Interactive login shell first: Debian/Ubuntu ~/.bashrc returns early when not interactive.
+    const attempts = [
+        ["-ilc", dump],
+        ["-lc", dump],
+    ];
+    for (const args of attempts) {
+        const out = await capture(shell, args, 15000, { ...env, TERM: "dumb" });
+        const parsed = extractJson(out);
+        if (parsed)
+            return parsed;
+    }
+    return undefined;
+}
+function quote(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function extractJson(out) {
+    if (!out)
+        return undefined;
+    const start = out.indexOf(BEGIN);
+    const end = out.lastIndexOf(END);
+    if (start === -1 || end === -1 || end <= start)
+        return undefined;
+    try {
+        const parsed = JSON.parse(out.slice(start + BEGIN.length, end).trim());
+        if (typeof parsed !== "object" || parsed === null)
+            return undefined;
+        const result = {};
+        for (const [k, v] of Object.entries(parsed)) {
+            if (typeof v === "string")
+                result[k] = v;
+        }
+        return result;
+    }
+    catch {
+        return undefined;
+    }
+}
+function capture(file, args, timeoutMs, env = process.env) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(file, args, { stdio: ["ignore", "pipe", "pipe"], env, windowsHide: true });
+        }
+        catch {
+            resolve(undefined);
+            return;
+        }
+        let stdout = "";
+        child.stdout?.on("data", (d) => (stdout += d.toString()));
+        child.stderr?.on("data", () => undefined);
+        const timer = setTimeout(() => child.kill(), timeoutMs);
+        child.on("error", () => {
+            clearTimeout(timer);
+            resolve(undefined);
+        });
+        child.on("close", () => {
+            clearTimeout(timer);
+            resolve(stdout);
+        });
+    });
+}

package/dist/src/github.js

@@ -0,0 +1,62 @@
+import { spawn } from "node:child_process";
+import { findOnPath } from "./which.js";
+import { log } from "./log.js";
+export const DEFAULT_CONFIG_FILENAME = "envsync.json";
+/**
+ * Parse `owner/repo`, `owner/repo@ref`, `owner/repo:path/to/file.json`
+ * or `owner/repo@ref:path`. Path defaults to envsync.json at the repo root.
+ */
+export function parseGitHubRef(input) {
+    const trimmed = input.trim().replace(/^https?:\/\/github\.com\//, "").replace(/\.git$/, "");
+    const colon = trimmed.indexOf(":");
+    const repoPart = colon === -1 ? trimmed : trimmed.slice(0, colon);
+    const filePath = colon === -1 ? DEFAULT_CONFIG_FILENAME : trimmed.slice(colon + 1).replace(/^\/+/, "");
+    const at = repoPart.indexOf("@");
+    const ownerRepo = at === -1 ? repoPart : repoPart.slice(0, at);
+    const ref = at === -1 ? undefined : repoPart.slice(at + 1);
+    const [owner, repo, ...rest] = ownerRepo.split("/").filter(Boolean);
+    if (!owner || !repo || rest.length) {
+        throw new Error(`Expected "owner/repo[@ref][:path]", got "${input}"`);
+    }
+    return { owner, repo, ref: ref || undefined, path: filePath || DEFAULT_CONFIG_FILENAME };
+}
+/** Read a file from GitHub. Uses `gh` when present (private repos work), else raw.githubusercontent.com. */
+export async function fetchFromGitHub(ref) {
+    if (findOnPath("gh")) {
+        const endpoint = `repos/${ref.owner}/${ref.repo}/contents/${ref.path}${ref.ref ? `?ref=${encodeURIComponent(ref.ref)}` : ""}`;
+        log.debug(`gh api ${endpoint}`);
+        const result = await run("gh", ["api", endpoint, "-H", "Accept: application/vnd.github.raw+json"]);
+        if (result.code === 0)
+            return result.stdout;
+        log.debug(`gh api failed (${result.code}): ${result.stderr.trim()}`);
+        log.warn(null, "gh could not read the file, trying raw.githubusercontent.com");
+    }
+    else {
+        log.debug("gh not found on PATH, using raw.githubusercontent.com (public repos only)");
+    }
+    const url = `https://raw.githubusercontent.com/${ref.owner}/${ref.repo}/${ref.ref ?? "HEAD"}/${ref.path}`;
+    const headers = {};
+    const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    return fetchText(url, headers);
+}
+export async function fetchText(url, headers = {}) {
+    log.debug(`GET ${url}`);
+    const response = await fetch(url, { headers, redirect: "follow" });
+    if (!response.ok) {
+        throw new Error(`GET ${url} failed: ${response.status} ${response.statusText}`);
+    }
+    return response.text();
+}
+function run(file, args) {
+    return new Promise((resolve) => {
+        const child = spawn(file, args, { stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => (stdout += d.toString()));
+        child.stderr.on("data", (d) => (stderr += d.toString()));
+        child.on("error", (err) => resolve({ code: 1, stdout, stderr: err.message }));
+        child.on("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
+    });
+}

package/dist/src/jsonc.js

@@ -0,0 +1,74 @@
+/**
+ * Strip `//` and `/* *\/` comments plus trailing commas so hand written
+ * config files can carry notes. String contents are left untouched.
+ */
+export function stripJsonComments(input) {
+    let out = "";
+    let i = 0;
+    const n = input.length;
+    while (i < n) {
+        const ch = input[i];
+        const next = input[i + 1];
+        if (ch === '"') {
+            const j = endOfString(input, i);
+            out += input.slice(i, j + 1);
+            i = j + 1;
+            continue;
+        }
+        if (ch === "/" && next === "/") {
+            while (i < n && input[i] !== "\n")
+                i++;
+            continue;
+        }
+        if (ch === "/" && next === "*") {
+            const end = input.indexOf("*/", i + 2);
+            i = end === -1 ? n : end + 2;
+            continue;
+        }
+        out += ch;
+        i++;
+    }
+    return removeTrailingCommas(out);
+}
+function endOfString(input, start) {
+    let j = start + 1;
+    while (j < input.length) {
+        if (input[j] === "\\") {
+            j += 2;
+            continue;
+        }
+        if (input[j] === '"')
+            break;
+        j++;
+    }
+    return j;
+}
+function removeTrailingCommas(input) {
+    let out = "";
+    let i = 0;
+    const n = input.length;
+    while (i < n) {
+        const ch = input[i];
+        if (ch === '"') {
+            const j = endOfString(input, i);
+            out += input.slice(i, j + 1);
+            i = j + 1;
+            continue;
+        }
+        if (ch === ",") {
+            let j = i + 1;
+            while (j < n && /\s/.test(input[j]))
+                j++;
+            if (input[j] === "}" || input[j] === "]") {
+                i++;
+                continue;
+            }
+        }
+        out += ch;
+        i++;
+    }
+    return out;
+}
+export function parseJsonc(text) {
+    return JSON.parse(stripJsonComments(text));
+}

package/dist/src/log.js

@@ -0,0 +1,47 @@
+const useColor = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+const ESC = String.fromCharCode(27);
+function paint(code, text) {
+    return useColor ? `${ESC}[${code}m${text}${ESC}[0m` : text;
+}
+export const c = {
+    dim: (t) => paint("2", t),
+    bold: (t) => paint("1", t),
+    green: (t) => paint("32", t),
+    yellow: (t) => paint("33", t),
+    red: (t) => paint("31", t),
+    cyan: (t) => paint("36", t),
+};
+let verbose = false;
+export function setVerbose(on) {
+    verbose = on;
+}
+export function isVerbose() {
+    return verbose;
+}
+export const log = {
+    info(msg) {
+        console.log(msg);
+    },
+    step(tool, msg) {
+        console.log(`${c.cyan(`[${tool}]`)} ${msg}`);
+    },
+    ok(tool, msg) {
+        console.log(`${c.cyan(`[${tool}]`)} ${c.green(msg)}`);
+    },
+    warn(tool, msg) {
+        const prefix = tool ? `${c.cyan(`[${tool}]`)} ` : "";
+        console.log(`${prefix}${c.yellow(msg)}`);
+    },
+    error(tool, msg) {
+        const prefix = tool ? `${c.cyan(`[${tool}]`)} ` : "";
+        console.error(`${prefix}${c.red(msg)}`);
+    },
+    debug(msg) {
+        if (verbose)
+            console.log(c.dim(`  ${msg}`));
+    },
+    command(cmd) {
+        for (const line of cmd.trim().split(/\r?\n/))
+            console.log(c.dim(`  $ ${line}`));
+    },
+};

package/dist/src/platform.js

@@ -0,0 +1,234 @@
+import fs from "node:fs";
+import os from "node:os";
+import { findOnPath } from "./which.js";
+const PACKAGE_MANAGERS = [
+    { selector: "apt", binaries: ["apt-get"], os: ["linux"] },
+    { selector: "dnf", binaries: ["dnf"], os: ["linux"] },
+    { selector: "yum", binaries: ["yum"], os: ["linux"] },
+    { selector: "pacman", binaries: ["pacman"], os: ["linux"] },
+    { selector: "zypper", binaries: ["zypper"], os: ["linux"] },
+    { selector: "apk", binaries: ["apk"], os: ["linux"] },
+    { selector: "nix", binaries: ["nix-env", "nix"], os: ["linux", "macos"] },
+    { selector: "brew", binaries: ["brew"], os: ["linux", "macos"] },
+    { selector: "port", binaries: ["port"], os: ["macos"] },
+    { selector: "snap", binaries: ["snap"], os: ["linux"] },
+    { selector: "flatpak", binaries: ["flatpak"], os: ["linux"] },
+    { selector: "winget", binaries: ["winget"], os: ["windows"] },
+    { selector: "choco", binaries: ["choco"], os: ["windows"] },
+    { selector: "scoop", binaries: ["scoop"], os: ["windows"] },
+];
+export const KNOWN_PACKAGE_MANAGERS = PACKAGE_MANAGERS.map((p) => p.selector);
+export function gatherFacts() {
+    const read = (file) => {
+        try {
+            return fs.readFileSync(file, "utf8");
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const facts = {
+        nodePlatform: process.platform,
+        arch: process.arch,
+        release: os.release(),
+        hasBinary: (name) => findOnPath(name) !== undefined,
+        env: process.env,
+        hasFile: (file) => fs.existsSync(file),
+        uid: typeof process.getuid === "function" ? process.getuid() : undefined,
+        stdinTty: Boolean(process.stdin.isTTY),
+        stdoutTty: Boolean(process.stdout.isTTY),
+    };
+    if (process.platform === "linux") {
+        const osRelease = read("/etc/os-release") ?? read("/usr/lib/os-release");
+        if (osRelease !== undefined)
+            facts.osRelease = osRelease;
+        const procVersion = read("/proc/version");
+        if (procVersion !== undefined)
+            facts.procVersion = procVersion;
+    }
+    return facts;
+}
+export function detectPlatform(facts = gatherFacts()) {
+    const osFamily = toOsFamily(facts.nodePlatform);
+    const arch = facts.arch;
+    let id = osFamily;
+    let version = "";
+    let like = [];
+    let wsl = false;
+    if (osFamily === "linux") {
+        const rel = parseOsRelease(facts.osRelease ?? "");
+        id = (rel.ID ?? "linux").toLowerCase();
+        version = rel.VERSION_ID ?? "";
+        like = (rel.ID_LIKE ?? "")
+            .split(/\s+/)
+            .map((s) => s.toLowerCase())
+            .filter((s) => s && s !== id);
+        wsl = /microsoft/i.test(facts.procVersion ?? "") || /microsoft/i.test(facts.release);
+    }
+    else if (osFamily === "macos") {
+        version = darwinToMacosVersion(facts.release);
+    }
+    else {
+        version = windowsVersion(facts.release);
+    }
+    const packageManagers = PACKAGE_MANAGERS.filter((pm) => pm.os.includes(osFamily) && pm.binaries.some((b) => facts.hasBinary(b))).map((pm) => pm.selector);
+    const host = detectHost(facts, wsl);
+    const root = facts.uid === 0;
+    const sudo = osFamily !== "windows" && !root && facts.hasBinary("sudo") ? "sudo" : "";
+    const partial = {
+        os: osFamily,
+        id,
+        version,
+        like,
+        packageManagers,
+        arch,
+        wsl,
+        host,
+        interactive: facts.stdinTty && facts.stdoutTty,
+        root,
+        sudo,
+        terminal: detectTerminal(facts.env),
+    };
+    return { ...partial, selectors: buildSelectors(partial) };
+}
+/**
+ * Things about where we run that are not the OS. Ordered: agent sandboxes,
+ * hosted workspaces, CI, container, WSL.
+ */
+export function detectHost(facts, wsl) {
+    const env = facts.env;
+    const out = [];
+    const truthy = (v) => v !== undefined && v !== "" && v !== "0" && v.toLowerCase() !== "false";
+    if (truthy(env.CLAUDECODE) || truthy(env.CLAUDE_CODE_ENTRYPOINT))
+        out.push("claude-code");
+    // Codex sets CODEX_SANDBOX / CODEX_SANDBOX_NETWORK_DISABLED and friends.
+    if (Object.keys(env).some((k) => k.startsWith("CODEX_")))
+        out.push("codex");
+    if (truthy(env.CODESPACES))
+        out.push("codespaces");
+    if (truthy(env.GITPOD_WORKSPACE_ID))
+        out.push("gitpod");
+    if (truthy(env.CI) || truthy(env.GITHUB_ACTIONS))
+        out.push("ci");
+    const inContainer = facts.hasFile("/.dockerenv") ||
+        facts.hasFile("/run/.containerenv") ||
+        truthy(env.container) ||
+        truthy(env.KUBERNETES_SERVICE_HOST);
+    if (inContainer)
+        out.push("container");
+    if (wsl)
+        out.push("wsl");
+    return out;
+}
+export function detectTerminal(env) {
+    if (env.TERM_PROGRAM)
+        return env.TERM_PROGRAM;
+    if (env.WT_SESSION)
+        return "windows-terminal";
+    return "";
+}
+/**
+ * Selector order, most specific first:
+ *   host (claude-code, codex, codespaces, gitpod, ci, container, wsl),
+ *   id-version, id-major, id, ID_LIKE entries, package managers, os family, unix, default
+ */
+export function buildSelectors(p) {
+    const out = [];
+    const push = (s) => {
+        if (s && !out.includes(s))
+            out.push(s);
+    };
+    for (const e of p.host)
+        push(e);
+    if (p.version) {
+        push(`${p.id}-${p.version}`);
+        const major = p.version.split(".")[0];
+        if (major && major !== p.version)
+            push(`${p.id}-${major}`);
+    }
+    push(p.id);
+    for (const l of p.like)
+        push(l);
+    for (const pm of p.packageManagers)
+        push(pm);
+    push(p.os);
+    if (p.os !== "windows")
+        push("unix");
+    push("default");
+    return out;
+}
+export function toOsFamily(nodePlatform) {
+    if (nodePlatform === "win32")
+        return "windows";
+    if (nodePlatform === "darwin")
+        return "macos";
+    return "linux";
+}
+export function parseOsRelease(text) {
+    const out = {};
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const eq = line.indexOf("=");
+        if (eq === -1)
+            continue;
+        const key = line.slice(0, eq).trim();
+        let value = line.slice(eq + 1).trim();
+        const quoted = (value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"));
+        if (quoted)
+            value = value.slice(1, -1);
+        out[key] = value.replace(/\\(.)/g, "$1");
+    }
+    return out;
+}
+/** Darwin kernel major to marketing version. Darwin 20 is macOS 11, and so on. */
+export function darwinToMacosVersion(release) {
+    const major = Number.parseInt(release.split(".")[0] ?? "", 10);
+    if (Number.isNaN(major))
+        return "";
+    if (major >= 20)
+        return String(major - 9);
+    if (major >= 5)
+        return `10.${major - 4}`;
+    return "";
+}
+/** NT build 22000 and above is Windows 11. */
+export function windowsVersion(release) {
+    const parts = release.split(".");
+    const build = Number.parseInt(parts[2] ?? "", 10);
+    const major = Number.parseInt(parts[0] ?? "", 10);
+    if (major === 10 && !Number.isNaN(build))
+        return build >= 22000 ? "11" : "10";
+    if (!Number.isNaN(major))
+        return String(major);
+    return "";
+}
+export function describePlatform(p) {
+    const bits = [`${p.id}${p.version ? " " + p.version : ""}`, p.arch];
+    if (p.like.length)
+        bits.push(`like: ${p.like.join(", ")}`);
+    if (p.host.length)
+        bits.push(`host: ${p.host.join(", ")}`);
+    if (p.packageManagers.length)
+        bits.push(`package managers: ${p.packageManagers.join(", ")}`);
+    return bits.join(" | ");
+}
+/** Environment variables every command can read. */
+export function platformEnvVars(p, shell) {
+    const vars = {
+        ENVSYNC_OS: p.os,
+        ENVSYNC_ID: p.id,
+        ENVSYNC_VERSION: p.version,
+        ENVSYNC_ARCH: p.arch,
+        ENVSYNC_SELECTORS: p.selectors.join(","),
+        ENVSYNC_HOST: p.host.join(","),
+        ENVSYNC_INTERACTIVE: p.interactive ? "1" : "0",
+        ENVSYNC_ROOT: p.root ? "1" : "0",
+        ENVSYNC_SUDO: p.sudo,
+        ENVSYNC_TERMINAL: p.terminal,
+    };
+    if (shell)
+        vars.ENVSYNC_SHELL = shell;
+    return vars;
+}

package/dist/src/resolve.js

@@ -0,0 +1,35 @@
+export function isCommandObject(value) {
+    return typeof value === "object" && value !== null && "run" in value;
+}
+export function isPlatformMap(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) && !isCommandObject(value);
+}
+/**
+ * Pick the command for this machine. Selectors are ordered most specific
+ * first, so `linuxmint` beats `ubuntu` beats `apt` beats `linux` beats `default`.
+ */
+export function resolveCommand(command, selectors) {
+    if (command === undefined)
+        return { kind: "undefined" };
+    if (!isPlatformMap(command))
+        return fromValue(command, "direct");
+    for (const selector of selectors) {
+        if (Object.prototype.hasOwnProperty.call(command, selector)) {
+            return fromValue(command[selector], selector);
+        }
+    }
+    return { kind: "no-match", available: Object.keys(command) };
+}
+function fromValue(value, selector) {
+    if (value === null)
+        return { kind: "skipped", selector };
+    if (typeof value === "string" || Array.isArray(value)) {
+        return { kind: "command", command: { ...toText(value), shell: undefined, selector } };
+    }
+    return { kind: "command", command: { ...toText(value.run), shell: value.shell, selector } };
+}
+function toText(value) {
+    if (typeof value === "string")
+        return { run: value, failFast: false };
+    return { run: value.join("\n"), failFast: true };
+}