toiljs 0.0.11 → 0.0.12

package/build/cli/diagnostics.js

@@ -0,0 +1,333 @@
+function parseVersion(v) {
+    const m = /(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(v);
+    if (!m)
+        return [0, 0, 0];
+    return [Number(m[1]), Number(m[2] ?? 0), Number(m[3] ?? 0)];
+}
+export function satisfiesMin(version, range) {
+    const [a, b, c] = parseVersion(version);
+    const [x, y, z] = parseVersion(range);
+    if (a !== x)
+        return a > x;
+    if (b !== y)
+        return b > y;
+    return c >= z;
+}
+export function checkNode(current, requiredRange) {
+    const ok = satisfiesMin(current, requiredRange);
+    return {
+        id: 'node',
+        label: 'Node.js',
+        status: ok ? 'pass' : 'fail',
+        detail: `${current} (requires ${requiredRange})`,
+        fix: ok ? undefined : `Upgrade Node to ${requiredRange}.`,
+    };
+}
+export function checkPeer(name, installed, range) {
+    if (installed === null) {
+        return {
+            id: `peer:${name}`,
+            label: name,
+            status: 'fail',
+            detail: `not installed (requires ${range})`,
+            fix: `Install ${name}@"${range}".`,
+        };
+    }
+    const ok = satisfiesMin(installed, range);
+    return {
+        id: `peer:${name}`,
+        label: name,
+        status: ok ? 'pass' : 'warn',
+        detail: `${installed} (requires ${range})`,
+        fix: ok ? undefined : `Update ${name} to ${range}.`,
+    };
+}
+export function checkPackageManager(lockfiles) {
+    if (lockfiles.length === 0) {
+        return {
+            id: 'pm',
+            label: 'Package manager',
+            status: 'warn',
+            detail: 'no lockfile found',
+            fix: 'Run an install (npm/pnpm/yarn/bun) to create a lockfile.',
+        };
+    }
+    return { id: 'pm', label: 'Package manager', status: 'pass', detail: lockfiles.join(', ') };
+}
+export function checkToiljsInstalled(version) {
+    return version
+        ? { id: 'toiljs', label: 'toiljs', status: 'pass', detail: version }
+        : {
+            id: 'toiljs',
+            label: 'toiljs',
+            status: 'fail',
+            detail: 'not a dependency of this project',
+            fix: 'Add toiljs to dependencies, or run from the project root with --root.',
+        };
+}
+export function checkDir(id, label, exists, fix) {
+    return exists
+        ? { id, label, status: 'pass' }
+        : { id, label, status: 'fail', detail: 'missing', fix };
+}
+export function checkMountSlots(entrySource) {
+    const label = 'App entry mount()';
+    if (entrySource === null) {
+        return {
+            id: 'mount',
+            label,
+            status: 'warn',
+            detail: 'entry file not found',
+            fix: 'Ensure client/toil.tsx calls Toil.mount(...).',
+        };
+    }
+    const call = /\bmount\s*\(([^)]*)\)/.exec(entrySource);
+    if (!call) {
+        return {
+            id: 'mount',
+            label,
+            status: 'warn',
+            detail: 'no mount() call found',
+            fix: 'Call Toil.mount(routes, layout, notFound, globalError, slots).',
+        };
+    }
+    const hasSlots = /\bslots\b/.test(call[1]);
+    return hasSlots
+        ? { id: 'mount', label, status: 'pass', detail: 'passes slots' }
+        : {
+            id: 'mount',
+            label,
+            status: 'warn',
+            detail: 'mount() is missing the slots argument',
+            fix: 'Pass slots last: mount(routes, layout, notFound, globalError, slots). Without it, parallel and intercepting routes are ignored.',
+        };
+}
+export function checkRootElement(indexHtml) {
+    const label = 'index.html mount target';
+    if (indexHtml === null) {
+        return {
+            id: 'root-el',
+            label,
+            status: 'fail',
+            detail: 'index.html not found',
+            fix: 'Add public/index.html with <div id="root"></div>.',
+        };
+    }
+    const ok = /id\s*=\s*["']root["']/.test(indexHtml);
+    return ok
+        ? { id: 'root-el', label, status: 'pass' }
+        : {
+            id: 'root-el',
+            label,
+            status: 'fail',
+            detail: 'no element with id="root"',
+            fix: 'Add <div id="root"></div> to public/index.html.',
+        };
+}
+export function checkRoutesPresent(routeCount) {
+    return routeCount > 0
+        ? {
+            id: 'routes',
+            label: 'Routes',
+            status: 'pass',
+            detail: `${routeCount} route${routeCount === 1 ? '' : 's'}`,
+        }
+        : {
+            id: 'routes',
+            label: 'Routes',
+            status: 'fail',
+            detail: 'no routes found',
+            fix: 'Add a page, e.g. client/routes/index.tsx.',
+        };
+}
+export function checkDuplicatePatterns(patterns) {
+    const seen = new Set();
+    const dupes = new Set();
+    for (const p of patterns) {
+        if (seen.has(p))
+            dupes.add(p);
+        else
+            seen.add(p);
+    }
+    return dupes.size === 0
+        ? { id: 'route-dupes', label: 'Unique route patterns', status: 'pass' }
+        : {
+            id: 'route-dupes',
+            label: 'Unique route patterns',
+            status: 'warn',
+            detail: `duplicate: ${[...dupes].join(', ')}`,
+            fix: 'Two route files map to the same URL; rename or remove one.',
+        };
+}
+function isBrokenRelativeAsset(value) {
+    if (value === '')
+        return false;
+    if (value.startsWith('/'))
+        return false;
+    if (/^[a-z][a-z0-9+.-]*:/i.test(value))
+        return false;
+    if (value.startsWith('#') || value.startsWith('?'))
+        return false;
+    return /\.(svgz?|png|jpe?g|gif|webp|avif|ico|css|m?js|woff2?|ttf|otf|eot|mp4|webm|json)$/i.test(value);
+}
+export function findRelativeAssets(files) {
+    const issues = [];
+    const attr = /\b(?:src|href)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+    for (const file of files) {
+        const lines = file.source.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            attr.lastIndex = 0;
+            let m;
+            while ((m = attr.exec(lines[i])) !== null) {
+                const value = m[1] ?? m[2] ?? '';
+                if (isBrokenRelativeAsset(value)) {
+                    issues.push({ file: file.path, line: i + 1, value });
+                }
+            }
+        }
+    }
+    return issues;
+}
+export function checkRelativeAssets(issues) {
+    if (issues.length === 0)
+        return { id: 'rel-assets', label: 'Asset paths', status: 'pass' };
+    const shown = issues
+        .slice(0, 5)
+        .map((i) => `${i.file}:${String(i.line)} "${i.value}"`)
+        .join('; ');
+    const more = issues.length > 5 ? `, and ${String(issues.length - 5)} more` : '';
+    return {
+        id: 'rel-assets',
+        label: 'Asset paths',
+        status: 'warn',
+        detail: `${String(issues.length)} relative reference(s): ${shown}${more}`,
+        fix: 'Use a root-absolute path (e.g. "/images/logo.svg") or import the asset; relative paths 404 on nested routes.',
+    };
+}
+export function checkConfigLoads(loaded, error) {
+    return loaded
+        ? { id: 'config', label: 'toil.config loads', status: 'pass' }
+        : {
+            id: 'config',
+            label: 'toil.config loads',
+            status: 'fail',
+            detail: error ?? 'failed to load',
+            fix: 'Fix the error in your toil.config.* so dev/build can read it.',
+        };
+}
+export function checkBasePath(base) {
+    const ok = base === '/' || (base.startsWith('/') && base.endsWith('/'));
+    return ok
+        ? { id: 'base', label: 'Base path', status: 'pass', detail: base }
+        : {
+            id: 'base',
+            label: 'Base path',
+            status: 'warn',
+            detail: `"${base}"`,
+            fix: 'A non-root base should start and end with "/" (e.g. "/app/").',
+        };
+}
+export function checkSeoUrl(seoConfigured, hasUrl) {
+    if (!seoConfigured) {
+        return {
+            id: 'seo-url',
+            label: 'SEO site url',
+            status: 'pass',
+            detail: 'SEO not configured',
+        };
+    }
+    return hasUrl
+        ? { id: 'seo-url', label: 'SEO site url', status: 'pass' }
+        : {
+            id: 'seo-url',
+            label: 'SEO site url',
+            status: 'warn',
+            detail: 'seo is set without a url',
+            fix: 'Set client.seo.url so sitemap.xml and canonical links are absolute.',
+        };
+}
+export function checkStyling(f) {
+    const label = 'Styling';
+    if (f.preprocessorImported && f.preprocessorImported !== 'css' && !f.preprocessorInstalled) {
+        return {
+            id: 'styling',
+            label,
+            status: 'fail',
+            detail: `${f.preprocessorImported} stylesheet imported but ${f.preprocessorImported} is not installed`,
+            fix: `Install ${f.preprocessorImported}, or run toiljs configure.`,
+        };
+    }
+    if (f.tailwindImported && !f.tailwindInstalled) {
+        return {
+            id: 'styling',
+            label,
+            status: 'fail',
+            detail: 'Tailwind entry imported but @tailwindcss/vite is not installed',
+            fix: 'Run toiljs configure --tailwind, or install @tailwindcss/vite.',
+        };
+    }
+    return { id: 'styling', label, status: 'pass' };
+}
+export function checkToilconfig(present) {
+    return present
+        ? { id: 'toilconfig', label: 'Server target (toilconfig.json)', status: 'pass' }
+        : {
+            id: 'toilconfig',
+            label: 'Server target (toilconfig.json)',
+            status: 'warn',
+            detail: 'no toilconfig.json (no WebAssembly server)',
+            fix: 'Add toilconfig.json + a server/ entry if you want a WASM backend.',
+        };
+}
+export function checkServerEntry(missing) {
+    return missing.length === 0
+        ? { id: 'server-entry', label: 'Server entries', status: 'pass' }
+        : {
+            id: 'server-entry',
+            label: 'Server entries',
+            status: 'fail',
+            detail: `missing: ${missing.join(', ')}`,
+            fix: 'Create the entry file(s) listed in toilconfig.json "entries", or update them.',
+        };
+}
+export function checkToilscriptInstalled(installed) {
+    return installed
+        ? { id: 'toilscript', label: 'toilscript compiler', status: 'pass' }
+        : {
+            id: 'toilscript',
+            label: 'toilscript compiler',
+            status: 'warn',
+            detail: 'toilconfig.json present but toilscript is not installed',
+            fix: 'Install toilscript to compile the server to WebAssembly.',
+        };
+}
+export function checkWasmBuilt(exists) {
+    return exists
+        ? { id: 'wasm', label: 'Server build', status: 'pass' }
+        : {
+            id: 'wasm',
+            label: 'Server build',
+            status: 'warn',
+            detail: 'no compiled .wasm found',
+            fix: 'Run your server build (toilscript) before toiljs start.',
+        };
+}
+export function summarize(groups) {
+    let pass = 0;
+    let warn = 0;
+    let fail = 0;
+    for (const group of groups) {
+        for (const check of group.checks) {
+            if (check.status === 'pass')
+                pass++;
+            else if (check.status === 'warn')
+                warn++;
+            else
+                fail++;
+        }
+    }
+    return { pass, warn, fail };
+}
+export function hasFailures(summary) {
+    return summary.fail > 0;
+}

package/build/cli/doctor.d.ts

@@ -0,0 +1,6 @@
+export interface DoctorOptions {
+    readonly root?: string;
+    readonly cwd: string;
+    readonly json?: boolean;
+}
+export declare function runDoctor(opts: DoctorOptions): Promise<void>;

package/build/cli/doctor.js

@@ -0,0 +1,249 @@
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadConfig, scanRoutes } from 'toiljs/compiler';
+import { checkBasePath, checkConfigLoads, checkDir, checkDuplicatePatterns, checkMountSlots, checkNode, checkPackageManager, checkPeer, checkRelativeAssets, checkRootElement, checkRoutesPresent, checkSeoUrl, checkServerEntry, checkStyling, checkToilconfig, checkToiljsInstalled, checkToilscriptInstalled, checkWasmBuilt, findRelativeAssets, hasFailures, summarize, } from './diagnostics.js';
+import { detectTailwind, PREPROCESSOR_PKG, preprocessorForExt, TAILWIND_ENTRY, } from './features.js';
+import { accent, bold, danger, dim, success, version, warn } from './ui.js';
+function readJsonObject(file) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return typeof parsed === 'object' && parsed !== null
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function stringRecord(value) {
+    if (typeof value !== 'object' || value === null)
+        return {};
+    const out = {};
+    for (const [k, v] of Object.entries(value))
+        if (typeof v === 'string')
+            out[k] = v;
+    return out;
+}
+function readFile(file) {
+    try {
+        return fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+function frameworkMeta() {
+    const pkgPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'package.json');
+    const pkg = readJsonObject(pkgPath);
+    const engines = pkg ? stringRecord(pkg.engines) : {};
+    const peers = pkg ? stringRecord(pkg.peerDependencies) : {};
+    return { node: engines.node ?? '>=24.0.0', peers };
+}
+const LOCKFILES = ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lockb'];
+function readEntry(clientAbsDir) {
+    for (const name of ['toil.tsx', 'toil.jsx', 'main.tsx', 'main.jsx']) {
+        const source = readFile(path.join(clientAbsDir, name));
+        if (source !== null && /toiljs\/routes|\bmount\s*\(/.test(source))
+            return source;
+    }
+    return null;
+}
+function collectSources(root, dir, cap) {
+    const out = [];
+    const visit = (current) => {
+        if (out.length >= cap)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (out.length >= cap)
+                break;
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name !== 'node_modules')
+                    visit(full);
+            }
+            else if (/\.(tsx|jsx)$/.test(entry.name)) {
+                const source = readFile(full);
+                if (source !== null)
+                    out.push({ path: path.relative(root, full), source });
+            }
+        }
+    };
+    visit(dir);
+    return out;
+}
+function glyph(status) {
+    if (status === 'pass')
+        return success('✓');
+    if (status === 'warn')
+        return warn('⚠');
+    return danger('✗');
+}
+function renderHuman(groups) {
+    const summary = summarize(groups);
+    const out = [];
+    for (const group of groups) {
+        out.push('  ' + bold(group.title));
+        for (const check of group.checks) {
+            let line = `    ${glyph(check.status)} ${check.label}`;
+            if (check.detail)
+                line += dim(`  ${check.detail}`);
+            out.push(line);
+            if (check.fix && check.status !== 'pass')
+                out.push('       ' + dim(`fix: ${check.fix}`));
+        }
+        out.push('');
+    }
+    const parts = [success(`${String(summary.pass)} passed`)];
+    if (summary.warn > 0) {
+        parts.push(warn(`${String(summary.warn)} warning${summary.warn === 1 ? '' : 's'}`));
+    }
+    if (summary.fail > 0)
+        parts.push(danger(`${String(summary.fail)} failed`));
+    out.push('  ' + parts.join(dim(', ')));
+    out.push('');
+    process.stdout.write(out.join('\n') + '\n');
+}
+export async function runDoctor(opts) {
+    const root = path.resolve(opts.root ?? opts.cwd);
+    const meta = frameworkMeta();
+    const projectPkg = readJsonObject(path.join(root, 'package.json'));
+    const deps = {
+        ...(projectPkg ? stringRecord(projectPkg.dependencies) : {}),
+        ...(projectPkg ? stringRecord(projectPkg.devDependencies) : {}),
+    };
+    let cfg = null;
+    let configError;
+    try {
+        cfg = await loadConfig({ root });
+    }
+    catch (err) {
+        configError = err instanceof Error ? err.message : String(err);
+    }
+    const clientAbsDir = cfg ? cfg.clientAbsDir : path.join(root, 'client');
+    const routesAbsDir = cfg ? cfg.routesAbsDir : path.join(clientAbsDir, 'routes');
+    const publicDir = cfg ? cfg.publicDir : path.join(clientAbsDir, 'public');
+    const entrySource = readEntry(clientAbsDir);
+    const indexHtml = readFile(path.join(publicDir, 'index.html'));
+    const routes = scanRoutes(routesAbsDir);
+    const mainPatterns = routes.filter((r) => r.slot === undefined).map((r) => r.pattern);
+    const assetIssues = findRelativeAssets(collectSources(root, clientAbsDir, 200));
+    let preprocessorImported = null;
+    let tailwindImported = false;
+    if (entrySource) {
+        const styleImport = /import\s+['"]\.\/styles\/main\.([a-z]+)['"]/.exec(entrySource);
+        if (styleImport)
+            preprocessorImported = preprocessorForExt(styleImport[1]);
+        tailwindImported = entrySource.includes(TAILWIND_ENTRY);
+    }
+    const ppPkg = preprocessorImported ? PREPROCESSOR_PKG[preprocessorImported] : null;
+    const preprocessorInstalled = ppPkg === null || ppPkg in deps;
+    const toilconfig = readJsonObject(path.join(root, 'toilconfig.json'));
+    const serverPresent = toilconfig !== null;
+    let missingEntries = [];
+    let toilscriptInstalled = false;
+    let wasmExists = false;
+    if (toilconfig) {
+        const entries = Array.isArray(toilconfig.entries)
+            ? toilconfig.entries.filter((e) => typeof e === 'string')
+            : [];
+        missingEntries = entries.filter((e) => !fs.existsSync(path.join(root, e)));
+        try {
+            createRequire(path.join(root, 'package.json')).resolve('toilscript');
+            toilscriptInstalled = true;
+        }
+        catch {
+            toilscriptInstalled = false;
+        }
+        const targets = typeof toilconfig.targets === 'object' && toilconfig.targets !== null
+            ? toilconfig.targets
+            : {};
+        const outFiles = [];
+        for (const target of Object.values(targets)) {
+            if (typeof target === 'object' && target !== null) {
+                const outFile = target.outFile;
+                if (typeof outFile === 'string')
+                    outFiles.push(outFile);
+            }
+        }
+        wasmExists = outFiles.some((f) => fs.existsSync(path.join(root, f)));
+        if (!wasmExists && outFiles.length === 0) {
+            try {
+                wasmExists = fs
+                    .readdirSync(path.join(root, 'build', 'server'))
+                    .some((f) => f.endsWith('.wasm'));
+            }
+            catch {
+                wasmExists = false;
+            }
+        }
+    }
+    const peerName = (n) => checkPeer(n, deps[n] ?? null, meta.peers[n] ?? '*');
+    const peerChecks = Object.keys(meta.peers).map(peerName);
+    const groups = [
+        {
+            title: 'Environment',
+            checks: [
+                checkNode(process.versions.node, meta.node),
+                checkToiljsInstalled('toiljs' in deps ? version() : null),
+                ...peerChecks,
+                checkPackageManager(LOCKFILES.filter((f) => fs.existsSync(path.join(root, f)))),
+            ],
+        },
+        {
+            title: 'Project + routing',
+            checks: [
+                checkDir('client-dir', 'client/ directory', fs.existsSync(clientAbsDir), 'Create a client/ directory for your app.'),
+                checkDir('routes-dir', 'routes/ directory', fs.existsSync(routesAbsDir), 'Create client/routes/ and add an index.tsx.'),
+                checkRootElement(indexHtml),
+                checkMountSlots(entrySource),
+                checkRoutesPresent(routes.length),
+                checkDuplicatePatterns(mainPatterns),
+                checkRelativeAssets(assetIssues),
+            ],
+        },
+        {
+            title: 'Config + assets',
+            checks: [
+                checkConfigLoads(cfg !== null, configError),
+                checkBasePath(cfg ? cfg.base : '/'),
+                checkSeoUrl(cfg?.seo != null, cfg?.seo?.url != null),
+                checkStyling({
+                    preprocessorImported,
+                    preprocessorInstalled,
+                    tailwindImported,
+                    tailwindInstalled: detectTailwind(deps),
+                }),
+            ],
+        },
+        {
+            title: 'Server / WASM',
+            checks: serverPresent
+                ? [
+                    checkToilconfig(true),
+                    checkServerEntry(missingEntries),
+                    checkToilscriptInstalled(toilscriptInstalled),
+                    checkWasmBuilt(wasmExists),
+                ]
+                : [checkToilconfig(false)],
+        },
+    ];
+    const summary = summarize(groups);
+    if (opts.json) {
+        process.stdout.write(JSON.stringify({ groups, summary }, null, 2) + '\n');
+    }
+    else {
+        process.stdout.write('\n' + accent('  Doctor') + dim(`  ${root}`) + '\n\n');
+        renderHuman(groups);
+    }
+    if (hasFailures(summary))
+        process.exitCode = 1;
+}

package/build/cli/index.js

@@ -2,6 +2,8 @@
 import { build, dev, start } from 'toiljs/compiler';
 import { runConfigure } from './configure.js';
 import { runCreate } from './create.js';
+import { runDoctor } from './doctor.js';
+import { runUpdate } from './update.js';
 import { PREPROCESSORS } from './features.js';
 import { accent, banner, bold, danger, dim, success, version } from './ui.js';
 function parseArgs(argv) {
@@ -68,6 +70,12 @@ function parseArgs(argv) {
             case '--yes':
                 flags.yes = true;
                 break;
+            case '--json':
+                flags.json = true;
+                break;
+            case '--target':
+                flags.target = argv[++i];
+                break;
             default:
                 if (!arg.startsWith('-') && flags.name === undefined)
                     flags.name = arg;
@@ -86,6 +94,8 @@ function printHelp() {
         cmd('dev', 'start the dev server with HMR'),
         cmd('build', 'build the optimized production bundle'),
         cmd('start', 'self-host the built app (hyper-express / uWS)'),
+        cmd('doctor', 'diagnose project setup and dependencies'),
+        cmd('update', 'check for and apply dependency updates'),
         '',
         bold('Options'),
         cmd('--root <dir>', 'project root (default: current directory)'),
@@ -96,6 +106,8 @@ function printHelp() {
         cmd('--no-ai', 'create: skip AI assistant files (CLAUDE.md, etc.)'),
         cmd('-y, --yes', 'create: accept defaults (non-interactive)'),
         cmd('--no-install', "create: don't install dependencies"),
+        cmd('--json', 'doctor: machine-readable output'),
+        cmd('--target <t>', 'update: latest | minor | patch | newest | greatest'),
         cmd('-v, --version', 'print the toiljs version'),
         '',
     ].join('\n') + '\n');
@@ -156,6 +168,20 @@ async function main() {
                 '\n\n');
             break;
         }
+        case 'doctor':
+            if (!flags.json)
+                banner();
+            await runDoctor({ root: flags.root, cwd: process.cwd(), json: flags.json });
+            break;
+        case 'update':
+            banner();
+            await runUpdate({
+                root: flags.root,
+                cwd: process.cwd(),
+                yes: flags.yes,
+                target: flags.target,
+            });
+            break;
         case 'help':
         case '--help':
         case '-h':

package/build/cli/proc.d.ts

@@ -1 +1,6 @@
 export declare function run(cmd: string, args: string[], cwd: string): Promise<void>;
+export declare function capture(cmd: string, args: string[], cwd: string): Promise<{
+    stdout: string;
+    stderr: string;
+    code: number;
+}>;

package/build/cli/proc.js

@@ -9,3 +9,23 @@ export function run(cmd, args, cwd) {
         child.on('close', (code) => code === 0 ? resolve() : reject(new Error(`${cmd} exited with code ${String(code)}`)));
     });
 }
+export function capture(cmd, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const onWindows = process.platform === 'win32';
+        const child = onWindows
+            ? spawn([cmd, ...args].join(' '), { cwd, shell: true })
+            : spawn(cmd, args, { cwd });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (d) => {
+            stdout += d.toString();
+        });
+        child.stderr?.on('data', (d) => {
+            stderr += d.toString();
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            resolve({ stdout, stderr, code: code ?? 1 });
+        });
+    });
+}

package/build/cli/ui.d.ts

@@ -4,5 +4,6 @@ export declare function brand(s: string): string;
 export declare const accent: typeof brand;
 export declare function success(s: string): string;
 export declare const danger: import("picocolors/types").Formatter;
+export declare const warn: import("picocolors/types").Formatter;
 export declare function version(): string;
 export declare function banner(): void;