toiljs 0.0.115 → 0.0.117

package/src/cli/features.ts

@@ -1,170 +0,0 @@
-/**
- * Pure description of toiljs's optional client styling features, a CSS preprocessor and Tailwind ,
- * shared by `create` (scaffold) and `configure` (toggle on existing projects). Dependency-light
- * (no node IO) so it can be unit-tested; the file writes and package-manager calls live in the
- * commands. Preprocessor and Tailwind are independent: Tailwind lives in its own `.css` entry so
- * it never passes through (and breaks on) a preprocessor's `@import` resolution.
- */
-
-/** Supported CSS preprocessor (`css` = none). */
-export type Preprocessor = 'css' | 'sass' | 'less' | 'stylus';
-
-/** The two independently-toggleable styling features of a project. */
-export interface StyleFeatures {
-    readonly preprocessor: Preprocessor;
-    readonly tailwind: boolean;
-}
-
-export const PREPROCESSORS: readonly Preprocessor[] = ['css', 'sass', 'less', 'stylus'];
-
-/** Main stylesheet extension for each preprocessor. */
-export const STYLE_EXT: Record<Preprocessor, string> = {
-    css: 'css',
-    sass: 'scss',
-    less: 'less',
-    stylus: 'styl',
-};
-
-/** npm package that enables each preprocessor in Vite (plain CSS needs none). */
-export const PREPROCESSOR_PKG: Record<Preprocessor, string | null> = {
-    css: null,
-    sass: 'sass',
-    less: 'less',
-    stylus: 'stylus',
-};
-
-/** Tailwind v4 packages. The framework auto-wires the Vite plugin when `@tailwindcss/vite` resolves. */
-export const TAILWIND_PKGS: readonly string[] = ['tailwindcss', '@tailwindcss/vite'];
-
-/**
- * Pinned versions for every package these features may install. `@tailwindcss/vite` must be
- * `>= 4.3.0`: earlier 4.x releases cap their `vite` peer at `^7`, so they ERESOLVE against the
- * Vite 8 toiljs ships (the "Tailwind broken on install" error). Keep both Tailwind pins in lockstep.
- */
-export const PKG_VERSION: Record<string, string> = {
-    sass: '^1.83.0',
-    less: '^4.2.1',
-    stylus: '^0.64.0',
-    tailwindcss: '^4.3.0',
-    '@tailwindcss/vite': '^4.3.0',
-};
-
-/** Dedicated Tailwind entry (kept `.css` so no preprocessor touches its `@import`). */
-export const TAILWIND_ENTRY = 'styles/tailwind.css';
-export const TAILWIND_CSS = `@import 'tailwindcss';\n`;
-
-/** Path (relative to `client/`) of the main stylesheet for a preprocessor. */
-export function styleEntry(p: Preprocessor): string {
-    return `styles/main.${STYLE_EXT[p]}`;
-}
-
-/** The preprocessor whose main stylesheet uses `ext` (with or without a leading dot), or null. */
-export function preprocessorForExt(ext: string): Preprocessor | null {
-    const e = ext.replace(/^\./, '');
-    if (e === 'sass') return 'sass';
-    return PREPROCESSORS.find((p) => STYLE_EXT[p] === e) ?? null;
-}
-
-/** Packages required by a feature set (preprocessor package + Tailwind packages). */
-export function requiredPackages(f: StyleFeatures): string[] {
-    const pkgs: string[] = [];
-    const pp = PREPROCESSOR_PKG[f.preprocessor];
-    if (pp) pkgs.push(pp);
-    if (f.tailwind) pkgs.push(...TAILWIND_PKGS);
-    return pkgs;
-}
-
-/** Managed packages to add and remove when moving from `from` to `to`. */
-export function packageDiff(
-    from: StyleFeatures,
-    to: StyleFeatures,
-): { add: string[]; remove: string[] } {
-    const want = new Set(requiredPackages(to));
-    const had = new Set(requiredPackages(from));
-    return {
-        add: [...want].filter((p) => !had.has(p)),
-        remove: [...had].filter((p) => !want.has(p)),
-    };
-}
-
-/** The side-effect style imports for the app entry, Tailwind first so app CSS can override it. */
-export function styleImportLines(f: StyleFeatures): string[] {
-    const lines: string[] = [];
-    if (f.tailwind) lines.push(`import './${TAILWIND_ENTRY}';`);
-    lines.push(`import './${styleEntry(f.preprocessor)}';`);
-    return lines;
-}
-
-/**
- * Rewrites the `./styles/*` side-effect imports in an app entry (`client/toil.tsx`) to match
- * `features`, preserving the rest of the file. Existing style imports are removed and the new
- * block is placed after the `toiljs/routes` import (or the last import, or the top).
- */
-export function setStyleImports(source: string, f: StyleFeatures): string {
-    const stripped = source.replace(
-        /^[ \t]*import\s+['"]\.\/styles\/[^'"]+['"];?[ \t]*\r?\n/gm,
-        '',
-    );
-    const block = styleImportLines(f).join('\n') + '\n';
-
-    const lines = stripped.split('\n');
-    const routesIdx = lines.findIndex((l) => /from\s+['"]toiljs\/routes['"]/.test(l));
-    let insertAt: number;
-    if (routesIdx !== -1) {
-        insertAt = routesIdx + 1;
-    } else {
-        const lastImport = lines.reduce((acc, l, i) => (/^\s*import\s/.test(l) ? i : acc), -1);
-        insertAt = lastImport + 1;
-    }
-    const head = lines.slice(0, insertAt).join('\n');
-    const tail = lines.slice(insertAt).join('\n');
-    return `${head}\n\n${block}\n${tail}`.replace(/\n{3,}/g, '\n\n');
-}
-
-/** A `toil.config` source containing `client: { images: <bool> }` (for scaffolding when none exists). */
-export function defaultConfigSource(images: boolean): string {
-    return (
-        "import { defineConfig } from 'toiljs/compiler';\n\n" +
-        'export default defineConfig({\n' +
-        '    client: {\n' +
-        '        // Optimize images at build time (resize/compress imported images).\n' +
-        `        images: ${String(images)},\n` +
-        '    },\n' +
-        '});\n'
-    );
-}
-
-/**
- * Sets the `client.images` flag in a `toil.config` source, returning the updated source, or `null`
- * if the file's shape isn't recognized (the caller should then fall back to a manual note). Handles
- * an existing `images:` value, an existing `client: {` block, or a bare `defineConfig({ … })`.
- */
-export function setConfigImages(source: string, enabled: boolean): string | null {
-    const value = String(enabled);
-    if (/\bimages\s*:\s*(?:true|false)/.test(source)) {
-        return source.replace(/\bimages\s*:\s*(?:true|false)/, `images: ${value}`);
-    }
-    if (/\bclient\s*:\s*\{/.test(source)) {
-        return source.replace(/\bclient\s*:\s*\{/, `client: {\n        images: ${value},`);
-    }
-    if (/defineConfig\(\s*\{/.test(source)) {
-        return source.replace(
-            /defineConfig\(\s*\{/,
-            `defineConfig({\n    client: { images: ${value} },`,
-        );
-    }
-    return null;
-}
-
-/** Detects the active preprocessor from a project's combined dependency map. */
-export function detectPreprocessor(deps: Record<string, string>): Preprocessor {
-    if ('sass' in deps) return 'sass';
-    if ('less' in deps) return 'less';
-    if ('stylus' in deps) return 'stylus';
-    return 'css';
-}
-
-/** Whether Tailwind is installed in a project's combined dependency map. */
-export function detectTailwind(deps: Record<string, string>): boolean {
-    return '@tailwindcss/vite' in deps || 'tailwindcss' in deps;
-}

package/src/cli/index.ts

@@ -1,326 +0,0 @@
-#!/usr/bin/env node
-/**
- * toiljs CLI. Routes `create` / `dev` / `build` and wraps them in the toiljs brand banner.
- * The compiler stays presentation-free (imported via the package's own `toiljs/compiler`
- * export); the epic bits, banner, the Clack scaffolding wizard, live here.
- */
-import { build, dev, start } from 'toiljs/compiler';
-
-import { runConfigure } from './configure.js';
-import { runCreate, type Template } from './create.js';
-import { runDb } from './db.js';
-import { runDoctor } from './doctor.js';
-import { notifyIfOutdated } from './notify.js';
-import { runUpdate } from './update.js';
-import { type Preprocessor, PREPROCESSORS } from './features.js';
-import { accent, banner, bold, danger, dim, success, version } from './ui.js';
-
-// Node 22+/26 prints an ExperimentalWarning the first time any code touches the
-// built-in `localStorage` global (some browser-oriented deps do when they are
-// evaluated server-side during the dev SSR pass). It is harmless (localStorage
-// works fine in the real browser) but noisy on every `toiljs dev`/`build`, so drop
-// exactly that one warning here, before anything runs. Every other warning still
-// prints. Installed on the CLI process, ahead of the compiler/dev work.
-const __origEmitWarning = process.emitWarning.bind(process) as (...a: unknown[]) => void;
-process.emitWarning = ((warning: unknown, ...rest: unknown[]): void => {
-    const msg = typeof warning === 'string' ? warning : (warning as { message?: string })?.message;
-    if (typeof msg === 'string' && msg.includes('localStorage is not available')) return;
-    __origEmitWarning(warning, ...rest);
-}) as typeof process.emitWarning;
-
-interface Flags {
-    root?: string;
-    port?: number;
-    host?: string;
-    threads?: number;
-    name?: string;
-    template?: Template;
-    preprocessor?: Preprocessor;
-    tailwind?: boolean;
-    ai?: boolean;
-    images?: boolean;
-    install?: boolean;
-    git?: boolean;
-    pm?: string;
-    yes?: boolean;
-    json?: boolean;
-    fix?: boolean;
-    target?: string;
-    server?: boolean;
-}
-
-function parseArgs(argv: string[]): Flags {
-    const flags: Flags = {};
-    for (let i = 0; i < argv.length; i++) {
-        const arg = argv[i];
-        switch (arg) {
-            case '--root':
-                flags.root = argv[++i];
-                break;
-            case '--port': {
-                const port = Number(argv[++i]);
-                if (!Number.isNaN(port)) flags.port = port;
-                break;
-            }
-            case '--host':
-                flags.host = argv[++i];
-                break;
-            case '--threads':
-            case '--workers': {
-                const threads = Number(argv[++i]);
-                if (!Number.isNaN(threads)) flags.threads = threads;
-                break;
-            }
-            case '--template':
-            case '-t': {
-                const t = argv[++i];
-                if (t === 'app' || t === 'minimal' || t === 'agent') flags.template = t;
-                break;
-            }
-            case '--pm':
-                flags.pm = argv[++i];
-                break;
-            case '--style': {
-                const s = argv[++i];
-                if ((PREPROCESSORS as readonly string[]).includes(s))
-                    flags.preprocessor = s as Preprocessor;
-                break;
-            }
-            case '--tailwind':
-                flags.tailwind = true;
-                break;
-            case '--no-tailwind':
-                flags.tailwind = false;
-                break;
-            case '--ai':
-                flags.ai = true;
-                break;
-            case '--no-ai':
-                flags.ai = false;
-                break;
-            case '--images':
-                flags.images = true;
-                break;
-            case '--no-images':
-                flags.images = false;
-                break;
-            case '--install':
-                flags.install = true;
-                break;
-            case '--no-install':
-                flags.install = false;
-                break;
-            case '--git':
-                flags.git = true;
-                break;
-            case '--no-git':
-                flags.git = false;
-                break;
-            case '-y':
-            case '--yes':
-                flags.yes = true;
-                break;
-            case '--json':
-                flags.json = true;
-                break;
-            case '--fix':
-                flags.fix = true;
-                break;
-            case '--target':
-                flags.target = argv[++i];
-                break;
-            case '--server':
-                flags.server = true;
-                break;
-            default:
-                if (!arg.startsWith('-') && flags.name === undefined) flags.name = arg;
-        }
-    }
-    return flags;
-}
-
-function printHelp(): void {
-    const cmd = (name: string, desc: string): string => `  ${accent(name.padEnd(15))}${dim(desc)}`;
-    process.stdout.write(
-        [
-            `${bold('Usage')}  ${dim('toiljs')} <command> [options]`,
-            '',
-            bold('Commands'),
-            cmd('create [name]', 'scaffold a new toiljs app'),
-            cmd('configure', 'toggle styling features (Sass/Less/Stylus, Tailwind)'),
-            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'),
-            cmd('db <action>', 'manage dev DB data (status | reset | export | import)'),
-            '',
-            bold('Options'),
-            cmd('--root <dir>', 'project root (default: current directory)'),
-            cmd('--port <n>', 'dev/start: listen port (or PORT env / client.port; default 3000)'),
-            cmd('--host <h>', 'dev/start: bind host, e.g. 0.0.0.0 (or HOST env / client.host; default 127.0.0.1)'),
-            cmd('--threads <n>', 'start: production HTTP worker count'),
-            cmd('-t, --template', 'create: app | minimal | agent'),
-            cmd('--style <name>', 'create/configure: css | sass | less | stylus'),
-            cmd('--tailwind', 'create/configure: enable Tailwind (--no-tailwind to remove)'),
-            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('--server', 'build: build only the server (regenerate shared/server.ts + wasm)'),
-            cmd('--json', 'doctor: machine-readable output'),
-            cmd('--fix', 'doctor: auto-fix what it can (typed-RPC wiring)'),
-            cmd('--target <t>', 'update: latest | minor | patch | newest | greatest'),
-            cmd('-v, --version', 'print the toiljs version'),
-            '',
-            dim('  Every command checks npm for a newer toiljs and warns when outdated.'),
-            dim('  Set TOILJS_NO_UPDATE_CHECK=1 to opt out.'),
-            '',
-        ].join('\n') + '\n',
-    );
-}
-
-async function main(): Promise<void> {
-    const [command, ...rest] = process.argv.slice(2);
-
-    if (command === '--version' || command === '-v') {
-        process.stdout.write(version() + '\n');
-        return;
-    }
-
-    const flags = parseArgs(rest);
-
-    // Every invocation (including `npm run dev` / `npm run build`, which call this CLI)
-    // checks that the installed toiljs is the latest release. Warns on stderr, never blocks
-    // the command; opt out with TOILJS_NO_UPDATE_CHECK=1.
-    await notifyIfOutdated(flags.root);
-
-    switch (command) {
-        case 'create':
-            banner();
-            await runCreate({
-                name: flags.name,
-                template: flags.template,
-                preprocessor: flags.preprocessor,
-                tailwind: flags.tailwind,
-                ai: flags.ai,
-                images: flags.images,
-                install: flags.install,
-                git: flags.git,
-                pm: flags.pm,
-                yes: flags.yes,
-                cwd: process.cwd(),
-            });
-            break;
-
-        case 'configure':
-            banner();
-            await runConfigure({
-                root: flags.root,
-                preprocessor: flags.preprocessor,
-                tailwind: flags.tailwind,
-                images: flags.images,
-                install: flags.install,
-                cwd: process.cwd(),
-            });
-            break;
-
-        case 'dev':
-            banner();
-            process.stdout.write(dim('  starting dev server…') + '\n\n');
-            await dev({ root: flags.root, port: flags.port, host: flags.host });
-            break;
-
-        case 'build':
-            banner();
-            process.stdout.write(
-                dim(flags.server ? '  building the server…' : '  building for production…') +
-                    '\n\n',
-            );
-            await build({ root: flags.root, serverOnly: flags.server });
-            process.stdout.write(
-                '\n' +
-                    success('  ✓ ') +
-                    bold(flags.server ? 'server build complete' : 'build complete') +
-                    '\n\n',
-            );
-            break;
-
-        case 'start': {
-            banner();
-            process.stdout.write(dim('  self-hosting the built app…') + '\n\n');
-            const server = await start({
-                root: flags.root,
-                port: flags.port,
-                host: flags.host,
-                threads: flags.threads,
-            });
-            // A wildcard bind (0.0.0.0/::) is not universally openable, so present a
-            // clickable loopback URL and separately flag that it is exposed.
-            const wildcard =
-                server.host === '0.0.0.0' || server.host === '::' || server.host === '';
-            const shownHost = wildcard ? 'localhost' : server.host;
-            const exposed =
-                server.host !== '127.0.0.1' && server.host !== 'localhost' && server.host !== '::1';
-            process.stdout.write(
-                accent('  ➜ ') +
-                    bold(`http://${shownHost}:${String(server.port)}`) +
-                    dim(`   ws channel: ${server.wsPath}`) +
-                    (exposed
-                        ? '\n' +
-                          dim(`     bound to ${server.host}:${String(server.port)} (exposed beyond loopback)`)
-                        : '') +
-                    '\n\n',
-            );
-            break;
-        }
-
-        case 'doctor':
-            // Skip the banner for --json so stdout stays valid JSON.
-            if (!flags.json) banner();
-            await runDoctor({
-                root: flags.root,
-                cwd: process.cwd(),
-                json: flags.json,
-                fix: flags.fix,
-            });
-            break;
-
-        case 'update':
-            banner();
-            await runUpdate({
-                root: flags.root,
-                cwd: process.cwd(),
-                yes: flags.yes,
-                target: flags.target,
-            });
-            break;
-
-        case 'db': {
-            // `toiljs db <action> [file]` — no banner so `path`/`export` pipe cleanly.
-            const action = rest[0];
-            const fileArg = rest[1] !== undefined && !rest[1].startsWith('-') ? rest[1] : undefined;
-            runDb(action, fileArg, { root: flags.root });
-            break;
-        }
-
-        case 'help':
-        case '--help':
-        case '-h':
-        case undefined:
-            banner();
-            printHelp();
-            break;
-
-        default:
-            banner();
-            process.stdout.write(dim(`  unknown command: ${command}`) + '\n\n');
-            printHelp();
-            process.exitCode = 1;
-    }
-}
-
-main().catch((err: unknown) => {
-    const message = err instanceof Error ? err.message : String(err);
-    process.stderr.write('\n' + danger('  ✗ ') + message + '\n');
-    process.exitCode = 1;
-});

package/src/cli/notify.ts

@@ -1,120 +0,0 @@
-/**
- * Automatic update check, run on every CLI invocation (so `npm run dev` / `npm run build`,
- * which call the toiljs CLI, are covered too). Asks the npm registry for the latest toiljs
- * release (answer cached for an hour in the user's cache dir, network capped at 2 seconds),
- * then warns on stderr when the project's installed toiljs or the running CLI is behind.
- * Never throws and never fails the command. Opt out with TOILJS_NO_UPDATE_CHECK=1 (also
- * honors NO_UPDATE_NOTIFIER and CI).
- */
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { detectPackageManager } from './update.js';
-import { accent, bold, box, dim, version as cliVersion, warn } from './ui.js';
-import { findOutdated, isCacheFresh, type OutdatedRow, parseCheckCache } from './version-check.js';
-
-const REGISTRY_URL = 'https://registry.npmjs.org/toiljs/latest';
-const FETCH_TIMEOUT_MS = 2000;
-
-/** Where the registry answer is cached: `$XDG_CACHE_HOME`/`~/.cache` + `toiljs/`. */
-function cacheFile(): string {
-    const base = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
-    return path.join(base, 'toiljs', 'update-check.json');
-}
-
-/** Asks the npm registry for the latest published version; null on any failure. */
-async function fetchLatest(): Promise<string | null> {
-    const ctrl = new AbortController();
-    const timer = setTimeout(() => {
-        ctrl.abort();
-    }, FETCH_TIMEOUT_MS);
-    try {
-        const res = await fetch(REGISTRY_URL, {
-            signal: ctrl.signal,
-            headers: { accept: 'application/json' },
-        });
-        if (!res.ok) return null;
-        const data: unknown = await res.json();
-        if (typeof data !== 'object' || data === null) return null;
-        const v = (data as Record<string, unknown>).version;
-        return typeof v === 'string' ? v : null;
-    } catch {
-        return null;
-    } finally {
-        clearTimeout(timer);
-    }
-}
-
-/**
- * The latest published toiljs version, from the cache when fresh, otherwise from the registry.
- * Failures are cached too (as null) so an offline machine backs off for the TTL instead of
- * paying the fetch timeout on every command.
- */
-async function resolveLatest(): Promise<string | null> {
-    const file = cacheFile();
-    try {
-        const cached = parseCheckCache(fs.readFileSync(file, 'utf8'));
-        if (cached && isCacheFresh(cached, Date.now())) return cached.latest;
-    } catch {}
-    const latest = await fetchLatest();
-    try {
-        fs.mkdirSync(path.dirname(file), { recursive: true });
-        fs.writeFileSync(file, JSON.stringify({ latest, checkedAt: Date.now() }));
-    } catch {}
-    return latest;
-}
-
-/** Reads the version of the toiljs resolved in the project's node_modules, if any. */
-function projectToiljsVersion(root: string): string | null {
-    try {
-        const raw = fs.readFileSync(
-            path.join(root, 'node_modules', 'toiljs', 'package.json'),
-            'utf8',
-        );
-        const parsed: unknown = JSON.parse(raw);
-        if (typeof parsed !== 'object' || parsed === null) return null;
-        const v = (parsed as Record<string, unknown>).version;
-        return typeof v === 'string' ? v : null;
-    } catch {
-        return null;
-    }
-}
-
-function noticeLines(latest: string, rows: OutdatedRow[]): string {
-    const header = warn('⚠ ') + bold(`a newer toiljs is available: ${accent(latest)}`);
-    const body = rows.map((row) => {
-        const where = row.scope === 'project' ? 'this project has' : 'your global CLI is';
-        return `${where} ${row.installed}${dim(', update with')} ${accent(row.command)}`;
-    });
-    return '\n' + box([header, '', ...body], warn) + '\n';
-}
-
-/**
- * Checks the project install and the running CLI against the latest release and prints a
- * warning to stderr when either is behind. Safe to await unconditionally: bounded by the
- * cache TTL + fetch timeout, and it swallows every error.
- */
-export async function notifyIfOutdated(rootArg: string | undefined): Promise<void> {
-    try {
-        const env = process.env;
-        if (env.TOILJS_NO_UPDATE_CHECK || env.NO_UPDATE_NOTIFIER || env.CI) return;
-
-        const latest = await resolveLatest();
-        if (!latest) return;
-
-        const root = path.resolve(rootArg ?? process.cwd());
-        const cliDir = path.dirname(fileURLToPath(import.meta.url));
-        const cliIsLocal = cliDir.startsWith(path.join(root, 'node_modules') + path.sep);
-        const rows = findOutdated(
-            latest,
-            projectToiljsVersion(root),
-            cliVersion(),
-            cliIsLocal,
-            detectPackageManager(root).name,
-        );
-        if (rows.length === 0) return;
-        process.stderr.write(noticeLines(latest, rows));
-    } catch {}
-}

package/src/cli/proc.ts

@@ -1,56 +0,0 @@
-import { spawn } from 'node:child_process';
-
-/**
- * Spawns `cmd args` in `cwd`, resolving on a 0 exit code and rejecting otherwise. On Windows the
- * `npm`/`pnpm`/`yarn` shims are `.cmd` files that need a shell; passing an args array with
- * `shell: true` is deprecated (DEP0190), so the whole command is passed as one string there
- * (args are fixed/allowlisted, never raw user input). POSIX spawns directly.
- */
-export function run(
-    cmd: string,
-    args: string[],
-    cwd: string,
-    opts: { stdio?: 'ignore' | 'inherit' } = {},
-): Promise<void> {
-    return new Promise((resolve, reject) => {
-        const onWindows = process.platform === 'win32';
-        const stdio = opts.stdio ?? 'ignore';
-        const child = onWindows
-            ? spawn([cmd, ...args].join(' '), { cwd, stdio, shell: true })
-            : spawn(cmd, args, { cwd, stdio });
-        child.on('error', reject);
-        child.on('close', (code) =>
-            code === 0 ? resolve() : reject(new Error(`${cmd} exited with code ${String(code)}`)),
-        );
-    });
-}
-
-/**
- * Like {@link run}, but captures stdout/stderr and resolves with them plus the exit code (it never
- * rejects on a non-zero exit, the caller decides). Used to read JSON from tools like
- * `npm-check-updates`. Same Windows shell handling as {@link run}; args are fixed/allowlisted.
- */
-export function capture(
-    cmd: string,
-    args: string[],
-    cwd: string,
-): Promise<{ stdout: string; stderr: string; code: number }> {
-    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: Buffer) => {
-            stdout += d.toString();
-        });
-        child.stderr?.on('data', (d: Buffer) => {
-            stderr += d.toString();
-        });
-        child.on('error', reject);
-        child.on('close', (code) => {
-            resolve({ stdout, stderr, code: code ?? 1 });
-        });
-    });
-}