@uxmaltech/collab-cli 0.1.0

package/dist/lib/model-listing.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listModels = listModels;
+const node_https_1 = __importDefault(require("node:https"));
+const node_url_1 = require("node:url");
+function httpsGet(url, headers = {}, timeoutMs = 15_000) {
+    return new Promise((resolve, reject) => {
+        const parsed = new node_url_1.URL(url);
+        const req = node_https_1.default.request({
+            hostname: parsed.hostname,
+            port: parsed.port || 443,
+            path: parsed.pathname + parsed.search,
+            method: 'GET',
+            headers: { Accept: 'application/json', ...headers },
+        }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk.toString();
+            });
+            res.on('end', () => {
+                resolve({ statusCode: res.statusCode ?? 0, body: data });
+            });
+        });
+        req.setTimeout(timeoutMs, () => {
+            req.destroy(new Error('Model listing request timed out'));
+        });
+        req.on('error', reject);
+        req.end();
+    });
+}
+// ---------- Gemini ----------
+async function listGeminiModels(apiKey) {
+    const url = `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}&pageSize=100`;
+    const res = await httpsGet(url);
+    if (res.statusCode < 200 || res.statusCode >= 300) {
+        throw new Error(`Gemini API error (${res.statusCode})`);
+    }
+    const parsed = JSON.parse(res.body);
+    const models = (parsed.models ?? []);
+    return models
+        .filter((m) => m.supportedGenerationMethods?.includes('generateContent'))
+        .filter((m) => m.name.includes('gemini'))
+        .map((m) => ({
+        id: m.name.replace('models/', ''),
+        name: m.displayName,
+    }));
+}
+// ---------- OpenAI ----------
+async function listOpenAiModels(apiKey) {
+    const url = 'https://api.openai.com/v1/models';
+    const res = await httpsGet(url, { Authorization: `Bearer ${apiKey}` });
+    if (res.statusCode < 200 || res.statusCode >= 300) {
+        throw new Error(`OpenAI API error (${res.statusCode})`);
+    }
+    const parsed = JSON.parse(res.body);
+    const models = (parsed.data ?? []);
+    // Filter to chat/completion models, exclude fine-tuned, audio, realtime, embedding
+    const chatPrefixes = ['gpt-4', 'gpt-3.5', 'o3', 'o4', 'o1'];
+    const excludePatterns = ['realtime', 'audio', 'embed', 'tts', 'whisper', 'dall-e', 'davinci', 'babbage'];
+    return models
+        .filter((m) => chatPrefixes.some((p) => m.id.startsWith(p)))
+        .filter((m) => !excludePatterns.some((e) => m.id.includes(e)))
+        .map((m) => ({ id: m.id }))
+        .sort((a, b) => a.id.localeCompare(b.id));
+}
+// ---------- Anthropic ----------
+async function listAnthropicModels(apiKey) {
+    const url = 'https://api.anthropic.com/v1/models?limit=100';
+    const res = await httpsGet(url, {
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+    });
+    if (res.statusCode < 200 || res.statusCode >= 300) {
+        throw new Error(`Anthropic API error (${res.statusCode})`);
+    }
+    const parsed = JSON.parse(res.body);
+    const models = (parsed.data ?? []);
+    return models.map((m) => ({
+        id: m.id,
+        name: m.display_name,
+    }));
+}
+// ---------- Public API ----------
+/**
+ * Lists available models from a provider's API.
+ * Validates the API key in the process — throws on invalid key.
+ */
+async function listModels(provider, apiKey) {
+    switch (provider) {
+        case 'gemini':
+            return listGeminiModels(apiKey);
+        case 'codex':
+            return listOpenAiModels(apiKey);
+        case 'claude':
+            return listAnthropicModels(apiKey);
+        case 'copilot':
+            return [];
+    }
+}

package/dist/lib/model-registry.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRegistryPath = getRegistryPath;
+exports.loadRegistry = loadRegistry;
+exports.saveProviderModels = saveProviderModels;
+exports.loadProviderModels = loadProviderModels;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function getRegistryPath(config) {
+    return node_path_1.default.join(config.collabDir, 'models.json');
+}
+/**
+ * Loads the full model registry. Returns an empty registry if the file
+ * does not exist or cannot be parsed.
+ */
+function loadRegistry(config) {
+    const registryPath = getRegistryPath(config);
+    if (!node_fs_1.default.existsSync(registryPath)) {
+        return { updatedAt: new Date().toISOString(), providers: {} };
+    }
+    try {
+        const raw = node_fs_1.default.readFileSync(registryPath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return { updatedAt: new Date().toISOString(), providers: {} };
+    }
+}
+/**
+ * Saves model listing results for a provider into the registry.
+ * Merges with existing entries for other providers.
+ */
+function saveProviderModels(config, provider, models) {
+    const registry = loadRegistry(config);
+    const now = new Date().toISOString();
+    registry.updatedAt = now;
+    registry.providers[provider] = {
+        queriedAt: now,
+        models,
+    };
+    const registryPath = getRegistryPath(config);
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(registryPath), { recursive: true });
+    node_fs_1.default.writeFileSync(registryPath, JSON.stringify(registry, null, 2), 'utf8');
+}
+/**
+ * Loads stored models for a single provider.
+ * Returns null if no entry exists.
+ */
+function loadProviderModels(config, provider) {
+    const registry = loadRegistry(config);
+    return registry.providers[provider] ?? null;
+}

package/dist/lib/npm-operations.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireNpm = requireNpm;
+exports.npmGlobalInstall = npmGlobalInstall;
+exports.npmGlobalUninstall = npmGlobalUninstall;
+const node_child_process_1 = require("node:child_process");
+const ansi_1 = require("./ansi");
+const shell_1 = require("./shell");
+const NPM_PACKAGE = '@uxmaltech/collab-cli';
+const PERMISSION_ERROR = /EACCES|permission denied/i;
+/**
+ * Resolves the npm binary path or writes an error and returns null.
+ */
+function requireNpm() {
+    const npmPath = (0, shell_1.resolveCommandPath)('npm');
+    if (!npmPath) {
+        process.stderr.write((0, ansi_1.red)(`${ansi_1.CROSS} npm not found in PATH. Install Node.js/npm first.\n`));
+    }
+    return npmPath;
+}
+/**
+ * Runs `npm install -g @uxmaltech/collab-cli@<version>`.
+ * Returns true on success, false on failure (with error already printed).
+ */
+function npmGlobalInstall(npmPath, version) {
+    const spec = `${NPM_PACKAGE}@${version}`;
+    try {
+        (0, node_child_process_1.execFileSync)(npmPath, ['install', '-g', spec], {
+            stdio: 'inherit',
+            timeout: 60_000,
+        });
+        return true;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (PERMISSION_ERROR.test(message)) {
+            process.stderr.write((0, ansi_1.red)(`${ansi_1.CROSS} Permission denied. Try:\n`) +
+                `  sudo npm install -g ${spec}\n`);
+        }
+        else {
+            process.stderr.write((0, ansi_1.red)(`${ansi_1.CROSS} Install failed: ${message}\n`));
+        }
+        return false;
+    }
+}
+/**
+ * Runs `npm uninstall -g @uxmaltech/collab-cli`.
+ * Returns true on success, false on failure (with error already printed).
+ */
+function npmGlobalUninstall(npmPath) {
+    try {
+        (0, node_child_process_1.execFileSync)(npmPath, ['uninstall', '-g', NPM_PACKAGE], {
+            stdio: 'inherit',
+            timeout: 60_000,
+        });
+        return true;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (PERMISSION_ERROR.test(message)) {
+            process.stderr.write((0, ansi_1.red)(`${ansi_1.CROSS} Permission denied. Try:\n`) +
+                `  sudo npm uninstall -g ${NPM_PACKAGE}\n`);
+        }
+        else {
+            process.stderr.write((0, ansi_1.red)(`${ansi_1.CROSS} Uninstall failed: ${message}\n`));
+        }
+        return false;
+    }
+}

package/dist/lib/orchestrator.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRepoBaseDir = getRepoBaseDir;
+exports.runOrchestration = runOrchestration;
+exports.runPerRepoOrchestration = runPerRepoOrchestration;
+const errors_1 = require("./errors");
+const state_1 = require("./state");
+/**
+ * Returns the effective base directory for stages that write per-repo files.
+ * In workspace mode (repoConfig present) this is the individual repo dir;
+ * in single-repo mode it falls back to workspaceDir.
+ */
+function getRepoBaseDir(ctx) {
+    const rc = ctx.options?._repoConfig;
+    return rc ? rc.repoDir : ctx.config.workspaceDir;
+}
+/**
+ * Inspects stderr for well-known platform-specific errors and returns
+ * additional recovery hints that are appended to the stage's recovery list.
+ */
+function detectPlatformHints(stderr) {
+    if (!stderr)
+        return [];
+    const hints = [];
+    // macOS: Docker credential helper cannot access the keychain
+    if (process.platform === 'darwin' &&
+        /keychain.*cannot be accessed|error getting credentials/i.test(stderr)) {
+        hints.push('macOS keychain is locked. Run: security unlock-keychain ~/Library/Keychains/login.keychain-db');
+    }
+    // Docker daemon not running
+    if (/cannot connect to.*docker daemon|is the docker daemon running/i.test(stderr)) {
+        hints.push('Docker daemon is not running. Start Docker Desktop or run: sudo systemctl start docker');
+    }
+    // Docker registry authentication failure (only in Docker/image contexts)
+    if (/(denied: requested access to the resource|unauthorized: authentication required|pull access denied)/i.test(stderr) &&
+        /(docker|ghcr\.io|image|manifest|pull)/i.test(stderr)) {
+        hints.push('Docker registry auth failed. Run: docker login ghcr.io');
+    }
+    // ARM64 / multi-platform manifest mismatch
+    if (/no matching manifest.*arm64|no matching manifest for.*platform/i.test(stderr)) {
+        hints.push('Image not available for this platform. Verify the image supports linux/arm64 or rebuild with --platform.');
+    }
+    // Network errors during image pull (only in Docker/image contexts)
+    if (/(network.*unreachable|timeout.*pull|dial tcp.*connection refused)/i.test(stderr) &&
+        /(docker|image|pull|manifest|registry)/i.test(stderr)) {
+        hints.push('Network error pulling images. Check internet connection and DNS settings.');
+    }
+    return hints;
+}
+function formatFailure(failure) {
+    const lines = [];
+    lines.push(`Stage '${failure.stage}' failed.`);
+    lines.push(failure.message);
+    if (failure.command) {
+        lines.push('');
+        lines.push(`Command: ${failure.command}`);
+    }
+    if (failure.stderr && failure.stderr.trim().length > 0) {
+        lines.push('');
+        lines.push('stderr:');
+        lines.push(failure.stderr.trim());
+    }
+    const platformHints = detectPlatformHints(failure.stderr);
+    const allRecovery = [...failure.recovery, ...platformHints];
+    if (allRecovery.length > 0) {
+        lines.push('');
+        lines.push('Recovery actions:');
+        for (const step of allRecovery) {
+            lines.push(`- ${step}`);
+        }
+    }
+    return lines.join('\n');
+}
+function currentWorkflowState(workflow) {
+    return {
+        completedStages: workflow?.completedStages ?? [],
+        updatedAt: workflow?.updatedAt ?? new Date().toISOString(),
+        failure: workflow?.failure,
+    };
+}
+async function runOrchestration(options, stages) {
+    const state = (0, state_1.loadState)(options.config);
+    const previous = currentWorkflowState(state.workflows[options.workflowId]);
+    const completed = new Set(options.resume ? previous.completedStages : []);
+    if (options.mode) {
+        options.logger.workflowHeader(options.workflowId, options.mode);
+    }
+    if (options.resume && completed.size > 0) {
+        options.logger.info(`Resuming '${options.workflowId}': ${completed.size}/${stages.length} stages complete.`);
+        for (const stage of stages) {
+            const status = completed.has(stage.id) ? '[done]' : '[pending]';
+            options.logger.info(`  ${status} ${stage.title}`);
+        }
+    }
+    const total = stages.length;
+    let stageIndex = 0;
+    for (const stage of stages) {
+        stageIndex++;
+        if (options.resume && completed.has(stage.id)) {
+            options.logger.info(`Skipping completed stage '${stage.title}'`);
+            continue;
+        }
+        options.logger.stageHeader(stageIndex, total, stage.title);
+        try {
+            await stage.run({
+                config: options.config,
+                executor: options.executor,
+                logger: options.logger,
+                options: options.stageOptions,
+            });
+            completed.add(stage.id);
+            state.workflows[options.workflowId] = {
+                completedStages: [...completed],
+                updatedAt: new Date().toISOString(),
+            };
+            (0, state_1.saveState)(options.config, state, options.executor);
+            options.logger.step(true, stage.title);
+        }
+        catch (error) {
+            const failure = {
+                stage: stage.id,
+                message: error instanceof Error ? error.message : String(error),
+                recovery: stage.recovery.length > 0 ? stage.recovery : ['Run the workflow again with --resume.'],
+                failedAt: new Date().toISOString(),
+            };
+            if (error instanceof errors_1.CommandExecutionError) {
+                failure.command = error.details.command;
+                failure.stderr = error.details.stderr || error.details.stdout;
+            }
+            state.workflows[options.workflowId] = {
+                completedStages: [...completed],
+                updatedAt: new Date().toISOString(),
+                failure,
+            };
+            (0, state_1.saveState)(options.config, state, options.executor);
+            throw new errors_1.CliError(formatFailure(failure));
+        }
+    }
+    state.workflows[options.workflowId] = {
+        completedStages: [...completed],
+        updatedAt: new Date().toISOString(),
+    };
+    (0, state_1.saveState)(options.config, state, options.executor);
+}
+/**
+ * Runs a set of stages scoped to a single repo inside a workspace.
+ *
+ * - Uses a namespaced workflow ID (`{baseId}:{repoName}`) for resume support.
+ * - Overrides `config.repoDir` and `config.aiDir` so existing stages write
+ *   into the repo instead of the workspace root.
+ * - Passes the `RepoConfig` via `stageOptions._repoConfig`.
+ */
+async function runPerRepoOrchestration(baseOptions, repoConfig, stages) {
+    const repoWorkflowId = `${baseOptions.workflowId}:${repoConfig.name}`;
+    const repoAwareConfig = {
+        ...baseOptions.config,
+        repoDir: repoConfig.architectureRepoDir,
+        aiDir: repoConfig.aiDir,
+    };
+    const stageOptions = {
+        ...baseOptions.stageOptions,
+        _repoConfig: repoConfig,
+    };
+    await runOrchestration({
+        ...baseOptions,
+        workflowId: repoWorkflowId,
+        config: repoAwareConfig,
+        stageOptions,
+    }, stages);
+}

package/dist/lib/parsers.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNumber = parseNumber;
+exports.parsePositiveInt = parsePositiveInt;
+exports.parseHealthOptions = parseHealthOptions;
+const errors_1 = require("./errors");
+/**
+ * Parses a string to a number, returning the fallback when the value
+ * is undefined or not a valid integer.
+ */
+function parseNumber(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isNaN(parsed) ? fallback : parsed;
+}
+/**
+ * Parses a string to a positive integer, throwing a CliError when the
+ * value is present but invalid. Returns the fallback for undefined values.
+ */
+function parsePositiveInt(flagName, value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new errors_1.CliError(`${flagName} must be a positive integer.`);
+    }
+    return parsed;
+}
+/**
+ * Builds a ServiceHealthOptions object from raw CLI option strings.
+ * Uses strict positive-integer validation to match `mcp start` behavior.
+ */
+function parseHealthOptions(options) {
+    return {
+        timeoutMs: parsePositiveInt('--timeout-ms', options.timeoutMs, 5_000),
+        retries: parsePositiveInt('--retries', options.retries, 15),
+        retryDelayMs: parsePositiveInt('--retry-delay-ms', options.retryDelayMs, 2_000),
+    };
+}

package/dist/lib/port-resolver.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAvailablePorts = resolveAvailablePorts;
+const node_net_1 = __importDefault(require("node:net"));
+const DEFAULT_PORTS = {
+    qdrant: 6333,
+    nebula: 9669,
+    mcp: 7337,
+};
+/**
+ * Tests whether a TCP port is available on 127.0.0.1.
+ * Returns true if the port is free.
+ */
+function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = node_net_1.default.createServer();
+        server.once('error', () => resolve(false));
+        server.once('listening', () => {
+            server.close(() => resolve(true));
+        });
+        server.listen(port, '127.0.0.1');
+    });
+}
+/**
+ * Finds the next available port starting from `start`, incrementing by 1.
+ * Skips ports already claimed in `reserved` to avoid collisions when
+ * multiple services are resolved in the same run.
+ * Throws if no port is found within 100 attempts.
+ */
+async function findAvailablePort(start, reserved) {
+    for (let port = start; port < start + 100; port++) {
+        if (reserved.has(port))
+            continue;
+        if (await isPortAvailable(port)) {
+            return port;
+        }
+    }
+    throw new Error(`No available port found in range ${start}–${start + 99}`);
+}
+/**
+ * Resolves available ports for Qdrant, NebulaGraph, and MCP.
+ * If default ports are in use, automatically increments to find free ones.
+ * Ports are resolved sequentially to avoid assigning the same port to
+ * multiple services.
+ */
+async function resolveAvailablePorts(defaults = DEFAULT_PORTS) {
+    const reserved = new Set();
+    const qdrant = await findAvailablePort(defaults.qdrant, reserved);
+    reserved.add(qdrant);
+    const nebula = await findAvailablePort(defaults.nebula, reserved);
+    reserved.add(nebula);
+    const mcp = await findAvailablePort(defaults.mcp, reserved);
+    return { qdrant, nebula, mcp };
+}

package/dist/lib/preconditions.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureCommandAvailable = ensureCommandAvailable;
+exports.ensureFileExists = ensureFileExists;
+exports.ensureWritableDirectory = ensureWritableDirectory;
+const node_fs_1 = __importDefault(require("node:fs"));
+const errors_1 = require("./errors");
+const shell_1 = require("./shell");
+function ensureCommandAvailable(commandName, options = {}) {
+    const resolved = (0, shell_1.resolveCommandPath)(commandName);
+    if (!resolved) {
+        if (options.dryRun) {
+            return null;
+        }
+        throw new errors_1.CliError(`Required command '${commandName}' is not available in PATH. Install it and retry.`);
+    }
+    return resolved;
+}
+function ensureFileExists(filePath, label = 'File') {
+    if (!node_fs_1.default.existsSync(filePath)) {
+        throw new errors_1.CliError(`${label} not found: ${filePath}`);
+    }
+}
+function ensureWritableDirectory(directoryPath) {
+    node_fs_1.default.mkdirSync(directoryPath, { recursive: true });
+    try {
+        node_fs_1.default.accessSync(directoryPath, node_fs_1.default.constants.W_OK);
+    }
+    catch {
+        throw new errors_1.CliError(`Directory is not writable: ${directoryPath}`);
+    }
+}

package/dist/lib/preflight.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPreflightChecks = runPreflightChecks;
+exports.assertPreflightChecks = assertPreflightChecks;
+const docker_checks_1 = require("./docker-checks");
+const errors_1 = require("./errors");
+const shell_1 = require("./shell");
+function commandCheck(commandName, fix, executor) {
+    const resolved = (0, shell_1.resolveCommandPath)(commandName);
+    if (!resolved) {
+        return {
+            id: commandName,
+            ok: false,
+            detail: `${commandName} not found in PATH`,
+            fix,
+        };
+    }
+    const version = executor.run(commandName, ['--version'], { check: false, verboseOnly: true });
+    const detail = version.stdout.trim() || version.stderr.trim();
+    const ok = version.status === 0;
+    return {
+        id: commandName,
+        ok,
+        detail: detail || (ok ? `found at ${resolved}` : `${commandName} --version exited with code ${version.status}`),
+        fix,
+    };
+}
+function dockerComposeCheck(executor) {
+    const dockerResolved = (0, shell_1.resolveCommandPath)('docker');
+    if (!dockerResolved) {
+        return {
+            id: 'docker-compose-plugin',
+            ok: false,
+            detail: 'docker command not found; cannot verify compose plugin',
+            fix: 'Install Docker Desktop or Docker Engine with compose plugin.',
+        };
+    }
+    const version = executor.run('docker', ['compose', 'version'], { check: false, verboseOnly: true });
+    const output = `${version.stdout}\n${version.stderr}`.trim();
+    if (version.status === 0) {
+        return {
+            id: 'docker-compose-plugin',
+            ok: true,
+            detail: output || 'docker compose plugin available',
+            fix: 'Install Docker Compose plugin.',
+        };
+    }
+    return {
+        id: 'docker-compose-plugin',
+        ok: false,
+        detail: output || 'docker compose plugin unavailable',
+        fix: 'Install Docker Compose plugin and verify with: docker compose version',
+    };
+}
+function runPreflightChecks(executor, opts) {
+    const results = [];
+    results.push(commandCheck('node', 'Install Node.js >= 20.', executor), commandCheck('npm', 'Install npm >= 10 (bundled with modern Node.js).', executor), commandCheck('python3', 'Install Python 3 (used by ingestion and tooling).', executor), commandCheck('docker', 'Install Docker Desktop or Docker Engine.', executor), dockerComposeCheck(executor));
+    // In indexed mode, verify the Docker daemon is actually reachable
+    // (skip if docker binary itself is missing — already reported above)
+    if (opts?.mode === 'indexed') {
+        const dockerCommandCheck = results.find((r) => r.id === 'docker');
+        if (dockerCommandCheck?.ok) {
+            const daemon = (0, docker_checks_1.checkDockerDaemon)(executor);
+            results.push({
+                id: 'docker-daemon',
+                ok: daemon.ok,
+                detail: daemon.ok
+                    ? `Docker daemon v${daemon.version}`
+                    : (daemon.error ?? 'Docker daemon unreachable'),
+                fix: 'Start Docker Desktop or run: sudo systemctl start docker',
+            });
+        }
+    }
+    return results;
+}
+function assertPreflightChecks(results, logger) {
+    const failed = results.filter((item) => !item.ok);
+    for (const item of results) {
+        const prefix = item.ok ? '[PASS]' : '[FAIL]';
+        logger.result(`${prefix} ${item.id}: ${item.detail}`);
+        if (!item.ok) {
+            logger.result(`       fix: ${item.fix}`);
+        }
+    }
+    if (failed.length > 0) {
+        throw new errors_1.CliError(`Preflight failed with ${failed.length} issue(s).`);
+    }
+}

package/dist/lib/process.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProcess = runProcess;
+function runProcess(executor, commandName, args, options = {}) {
+    return executor.run(commandName, args, options);
+}