@revoengine/cli 1.0.0

package/dist/src/commands/component.js

@@ -0,0 +1,905 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ApiError, PermissionDeniedError } from "../client.js";
+import { buildSandboxDebugUrl, extractSandboxEndpoint } from "../project.js";
+import { isInteractiveTerminal, promptConfirm } from "../prompt.js";
+import { deepClone, readBoolFlag, readFlag, readValues, sanitizeSegment, writeJsonFile } from "../utils.js";
+const NULL_CATEGORY_FOLDER = '__no_category__';
+const COMPONENT_LIST_PAGE_SIZE = 100;
+const ANSI = {
+    reset: '\u001b[0m',
+    bold: '\u001b[1m',
+    dim: '\u001b[2m',
+    green: '\u001b[32m',
+    yellow: '\u001b[33m',
+    cyan: '\u001b[36m',
+    blue: '\u001b[34m',
+    magenta: '\u001b[35m',
+};
+function supportsColor() {
+    return Boolean(process.stdout.isTTY || process.env.FORCE_COLOR);
+}
+function paint(text, code) {
+    return supportsColor() ? `${code}${text}${ANSI.reset}` : text;
+}
+function paintStatus(status) {
+    if (status === 'Skipped') {
+        return paint(status.padEnd(9), ANSI.bold + ANSI.yellow);
+    }
+    if (status === 'Notice') {
+        return paint(status.padEnd(9), ANSI.bold + ANSI.magenta);
+    }
+    return paint(status.padEnd(9), ANSI.bold + ANSI.green);
+}
+function paintPath(targetPath) {
+    return paint(targetPath, ANSI.cyan);
+}
+function paintEngine() {
+    return paint('RevoEngine', ANSI.bold + ANSI.blue);
+}
+function paintArrow(direction) {
+    return paint(direction === 'pull' ? '->' : '<-', ANSI.bold + ANSI.magenta);
+}
+function paintReason(reason) {
+    return paint(`(${reason})`, ANSI.dim + ANSI.yellow);
+}
+function rethrowComponentAccessError(error, action) {
+    if (error instanceof PermissionDeniedError) {
+        throw new Error(`Access denied (403). You are authenticated, but you do not have permission to ${action} components.`);
+    }
+    throw error;
+}
+function componentWorkspacePath(cwd, manifestPath) {
+    return path.relative(cwd, path.dirname(manifestPath)) || '.';
+}
+function printSyncStatus(println, input) {
+    const suffix = input.reason ? ` ${paintReason(input.reason)}` : '';
+    println(`${paintStatus(input.status)} ${paintEngine()} ${paintArrow(input.direction)} ${paintPath(input.targetPath)}${suffix}`);
+}
+function printNotice(println, message) {
+    println(`${paintStatus('Notice')} ${message}`);
+}
+function formatDuration(durationMs) {
+    if (durationMs < 1_000) {
+        return `${durationMs}ms`;
+    }
+    const seconds = durationMs / 1_000;
+    if (seconds < 10) {
+        return `${seconds.toFixed(1)}s`;
+    }
+    return `${Math.round(seconds)}s`;
+}
+function printSummary(println, label, results, durationMs) {
+    const primary = results.filter((result) => result.status === label.toLowerCase()).length;
+    const skipped = results.filter((result) => result.status === 'skipped').length;
+    const total = results.length;
+    const summary = skipped > 0
+        ? `${label} ${primary}/${total}, Skipped ${skipped}/${total} in ${formatDuration(durationMs)}`
+        : `${label} ${primary}/${total} in ${formatDuration(durationMs)}`;
+    println(summary);
+}
+function formatBulkCount(direction, count) {
+    if (typeof count === 'number') {
+        return direction === 'pull'
+            ? `${count} components from RevoEngine`
+            : `${count} local components to RevoEngine`;
+    }
+    return direction === 'pull'
+        ? `${count} from RevoEngine`
+        : `${count} to RevoEngine`;
+}
+async function confirmBulkAction(context, direction, count, force) {
+    if (force) {
+        return;
+    }
+    const action = direction === 'pull' ? 'pull' : 'push';
+    const subject = formatBulkCount(direction, count);
+    if (!isInteractiveTerminal()) {
+        throw new Error(`Bulk ${action} requires confirmation. Re-run with --force or use an interactive terminal.`);
+    }
+    printNotice(context.println, `About to ${action} ${subject}.`);
+    const confirmed = await promptConfirm('Continue?', false);
+    if (!confirmed) {
+        throw new Error('Cancelled.');
+    }
+}
+function readWorkspaceManifest(manifestPath) {
+    return JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+}
+function readWorkspaceComponentSafe(manifestPath) {
+    try {
+        return readWorkspaceComponent(manifestPath);
+    }
+    catch {
+        return null;
+    }
+}
+function findLocalManifestInfo(cwd, componentId) {
+    const manifestPath = findComponentManifestsById(cwd, componentId)[0];
+    if (!manifestPath) {
+        return null;
+    }
+    try {
+        const manifest = readWorkspaceManifest(manifestPath);
+        return {
+            manifestPath,
+            targetPath: componentWorkspacePath(cwd, manifestPath),
+            version: typeof manifest.version === 'number' ? manifest.version : null,
+        };
+    }
+    catch {
+        return {
+            manifestPath,
+            targetPath: componentWorkspacePath(cwd, manifestPath),
+            version: null,
+        };
+    }
+}
+function isNotModifiedError(error) {
+    if (!(error instanceof ApiError) || error.status !== 400) {
+        return false;
+    }
+    const message = typeof error.data === 'string'
+        ? error.data
+        : error.data && typeof error.data === 'object' && 'message' in error.data
+            ? String(error.data.message)
+            : error.message;
+    return /not modified/i.test(message);
+}
+function componentTypeToExtension(value) {
+    const normalized = value.toLowerCase();
+    if (normalized.includes('ts') || normalized === 'typescript') {
+        return 'ts';
+    }
+    if (normalized.includes('json')) {
+        return 'json';
+    }
+    if (normalized.includes('js') || normalized === 'javascript') {
+        return 'js';
+    }
+    return 'txt';
+}
+function compilerFromType(type, compiler) {
+    if (compiler) {
+        return compiler;
+    }
+    const normalized = (type || '').toLowerCase();
+    if (normalized.includes('ts')) {
+        return 'typescript';
+    }
+    if (normalized.includes('js')) {
+        return 'javascript';
+    }
+    return 'javascript';
+}
+function normalizeComponentType(component) {
+    if (component.type) {
+        return component.type;
+    }
+    if (component.compiler) {
+        const normalized = component.compiler.toLowerCase();
+        if (normalized.includes('typescript')) {
+            return 'CODE_TS';
+        }
+        if (normalized.includes('javascript')) {
+            return 'CODE_JS';
+        }
+    }
+    return 'CODE_JS';
+}
+function getWorkspaceRoot(cwd) {
+    return path.join(cwd, 'Components');
+}
+function getCategoryFolder(component) {
+    if (component.category == null || component.category === '') {
+        return NULL_CATEGORY_FOLDER;
+    }
+    return sanitizeSegment(component.category);
+}
+function getComponentFolder(component) {
+    const categoryFolder = getCategoryFolder(component);
+    const name = sanitizeSegment(component.name || 'component');
+    const componentId = sanitizeSegment(component.componentId || component.id || 'unknown');
+    return path.join(categoryFolder, `${name}-${componentId}`);
+}
+function getCategoryFromManifestPath(manifestPath) {
+    const componentDir = path.dirname(manifestPath);
+    const categoryDir = path.basename(path.dirname(componentDir));
+    if (categoryDir === NULL_CATEGORY_FOLDER) {
+        return null;
+    }
+    return categoryDir;
+}
+function normalizeCategoryForApi(manifestPath, category) {
+    if (category === NULL_CATEGORY_FOLDER) {
+        return null;
+    }
+    if (category != null) {
+        return category;
+    }
+    return getCategoryFromManifestPath(manifestPath);
+}
+function getDetailsExtension(component) {
+    return componentTypeToExtension(normalizeComponentType(component));
+}
+function stripDetails(component) {
+    const clone = deepClone(component);
+    clone.elements = (clone.elements || []).map((element) => {
+        const next = deepClone(element);
+        delete next.details;
+        return next;
+    });
+    clone.compiler = compilerFromType(clone.type, clone.compiler);
+    return clone;
+}
+function walkFiles(dir, output = []) {
+    if (!fs.existsSync(dir)) {
+        return output;
+    }
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === '.idea') {
+            continue;
+        }
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walkFiles(fullPath, output);
+        }
+        else if (entry.isFile()) {
+            output.push(fullPath);
+        }
+    }
+    return output;
+}
+function getComponentManifestPaths(root) {
+    return walkFiles(root).filter((filePath) => filePath.endsWith('component.json'));
+}
+function readWorkspaceComponent(manifestPath) {
+    const componentDir = path.dirname(manifestPath);
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    const detailDirs = [
+        path.join(componentDir, 'elements'),
+        path.join(componentDir, 'details'),
+    ].filter((dir, index, list) => list.indexOf(dir) === index);
+    const extension = componentTypeToExtension(normalizeComponentType(manifest));
+    manifest.elements = (manifest.elements || []).map((element) => {
+        const fileName = `${element.order}_${element.key}.${extension}`;
+        let details = '';
+        for (const detailDir of detailDirs) {
+            const preferredPath = path.join(detailDir, fileName);
+            if (fs.existsSync(preferredPath)) {
+                details = fs.readFileSync(preferredPath, 'utf8');
+                break;
+            }
+            if (fs.existsSync(detailDir)) {
+                const match = fs.readdirSync(detailDir).find((entry) => entry.startsWith(`${element.order}_${element.key}.`));
+                if (match) {
+                    details = fs.readFileSync(path.join(detailDir, match), 'utf8');
+                    break;
+                }
+            }
+        }
+        return {
+            ...element,
+            details,
+        };
+    });
+    return manifest;
+}
+function getComponentIdFromPath(componentPath) {
+    const basename = path.basename(componentPath);
+    const match = basename.match(/[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/i);
+    return match ? match[0] : basename;
+}
+function findComponentManifestsById(cwd, componentId) {
+    const root = getWorkspaceRoot(cwd);
+    return getComponentManifestPaths(root).filter((manifestPath) => {
+        try {
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+            if ((manifest.componentId || manifest.id || '').includes(componentId)) {
+                return true;
+            }
+        }
+        catch {
+            // Ignore malformed manifests and fall back to the folder name check.
+        }
+        return getComponentIdFromPath(path.dirname(manifestPath)).includes(componentId);
+    });
+}
+function unwrapList(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (value && typeof value === 'object') {
+        const candidate = value;
+        if (Array.isArray(candidate.data)) {
+            return candidate.data;
+        }
+        if (Array.isArray(candidate.items)) {
+            return candidate.items;
+        }
+    }
+    return [];
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function readNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function resolveNextComponentListRequest(value) {
+    if (typeof value === 'string' && value) {
+        return {
+            path: value,
+        };
+    }
+    if (!isRecord(value)) {
+        return null;
+    }
+    for (const key of ['path', 'url', 'href']) {
+        if (typeof value[key] === 'string' && value[key]) {
+            return {
+                path: value[key],
+            };
+        }
+    }
+    const query = {};
+    for (const key of ['cursor', 'page', 'skip', 'take', 'limit', 'offset']) {
+        const candidate = value[key];
+        if (typeof candidate === 'string' || typeof candidate === 'number') {
+            query[key] = candidate;
+        }
+    }
+    return Object.keys(query).length > 0 ? { query } : null;
+}
+function unwrapComponentListPage(value) {
+    const items = unwrapList(value);
+    if (!isRecord(value)) {
+        return {
+            items,
+            total: null,
+            nextRequest: null,
+        };
+    }
+    const meta = isRecord(value.meta) ? value.meta : null;
+    const pagination = isRecord(value.pagination) ? value.pagination : null;
+    const total = readNumber(value.total)
+        ?? readNumber(value.count)
+        ?? (meta ? readNumber(meta.total) ?? readNumber(meta.count) : null)
+        ?? (pagination ? readNumber(pagination.total) ?? readNumber(pagination.count) : null);
+    const nextRequest = resolveNextComponentListRequest(value.next)
+        ?? (meta ? resolveNextComponentListRequest(meta.next) : null)
+        ?? (pagination ? resolveNextComponentListRequest(pagination.next) : null);
+    return {
+        items,
+        total,
+        nextRequest,
+    };
+}
+function unwrapComponent(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        const candidate = value;
+        if (candidate.data && typeof candidate.data === 'object') {
+            return candidate.data;
+        }
+    }
+    return value;
+}
+function normalizeValue(value, fallback = null) {
+    return value ?? fallback;
+}
+function normalizeElementContract(element) {
+    return {
+        key: element.key,
+        desc: normalizeValue(element.desc),
+        hidden: Boolean(element.hidden),
+        order: element.order,
+        details: element.details ?? '',
+    };
+}
+function normalizeComponentContract(component) {
+    const componentId = component.componentId || component.id || '';
+    return {
+        componentId,
+        name: component.name || '',
+        category: normalizeValue(component.category),
+        desc: normalizeValue(component.desc),
+        active: component.active ?? true,
+        type: normalizeComponentType(component),
+        compiler: compilerFromType(component.type, component.compiler),
+        version: typeof component.version === 'number' ? component.version : null,
+        elements: [...(component.elements || [])]
+            .map((element) => normalizeElementContract(element))
+            .sort((left, right) => left.order - right.order || left.key.localeCompare(right.key)),
+    };
+}
+function isSameComponentContract(left, right) {
+    return JSON.stringify(normalizeComponentContract(left)) === JSON.stringify(normalizeComponentContract(right));
+}
+function buildPullDecision(cwd, remote) {
+    const remoteFolder = path.join(getWorkspaceRoot(cwd), getComponentFolder(remote));
+    const remoteTargetPath = path.relative(cwd, remoteFolder);
+    const componentId = remote.componentId || remote.id || '';
+    const localInfo = componentId ? findLocalManifestInfo(cwd, componentId) : null;
+    if (!localInfo?.manifestPath) {
+        return {
+            kind: 'pull',
+            targetPath: remoteTargetPath,
+        };
+    }
+    const localComponent = readWorkspaceComponentSafe(localInfo.manifestPath);
+    if (!localComponent) {
+        return {
+            kind: 'skip',
+            targetPath: localInfo.targetPath || remoteTargetPath,
+            reason: 'changed',
+        };
+    }
+    const localVersion = typeof localComponent.version === 'number' ? localComponent.version : null;
+    const remoteVersion = typeof remote.version === 'number' ? remote.version : null;
+    if (localVersion !== null && remoteVersion !== null && localVersion < remoteVersion) {
+        return {
+            kind: 'skip',
+            targetPath: localInfo.targetPath || remoteTargetPath,
+            reason: 'stale version',
+        };
+    }
+    if (isSameComponentContract(localComponent, remote)) {
+        return {
+            kind: 'skip',
+            targetPath: localInfo.targetPath || remoteTargetPath,
+            reason: 'no changes',
+        };
+    }
+    return {
+        kind: 'skip',
+        targetPath: localInfo.targetPath || remoteTargetPath,
+        reason: 'changed',
+    };
+}
+async function confirmSingleStalePull(context, targetPath) {
+    if (!isInteractiveTerminal()) {
+        throw new Error(`Local component is stale at ${targetPath}. Re-run with --stale or --force, or use an interactive terminal to confirm overwrite.`);
+    }
+    printNotice(context.println, `Local component is stale at ${targetPath}.`);
+    return promptConfirm('Overwrite local component with the remote version?', false);
+}
+async function pullSingleComponent(context, componentId, mode = { force: false, stale: false }) {
+    const { client, cwd, println } = context;
+    let component = null;
+    try {
+        component = unwrapComponent(await client.getComponent(componentId));
+    }
+    catch (error) {
+        rethrowComponentAccessError(error, 'pull');
+    }
+    if (!component) {
+        const result = {
+            status: 'skipped',
+            targetPath: componentId,
+            reason: 'component not found',
+        };
+        printSyncStatus(println, {
+            status: 'Skipped',
+            direction: 'pull',
+            targetPath: result.targetPath,
+            reason: result.reason,
+        });
+        return result;
+    }
+    const decision = buildPullDecision(cwd, component);
+    if (decision.kind === 'skip' && !mode.force) {
+        if (decision.reason === 'stale version') {
+            if (mode.stale) {
+                // Continue and overwrite stale local copies.
+            }
+            else if (mode.promptOnStale === false) {
+                const result = {
+                    status: 'skipped',
+                    targetPath: decision.targetPath,
+                    reason: decision.reason,
+                };
+                printSyncStatus(println, {
+                    status: 'Skipped',
+                    direction: 'pull',
+                    targetPath: result.targetPath,
+                    reason: result.reason,
+                });
+                return result;
+            }
+            else {
+                const confirmed = await confirmSingleStalePull(context, decision.targetPath);
+                if (!confirmed) {
+                    const result = {
+                        status: 'skipped',
+                        targetPath: decision.targetPath,
+                        reason: decision.reason,
+                    };
+                    printSyncStatus(println, {
+                        status: 'Skipped',
+                        direction: 'pull',
+                        targetPath: result.targetPath,
+                        reason: result.reason,
+                    });
+                    return result;
+                }
+            }
+        }
+        else {
+            const result = {
+                status: 'skipped',
+                targetPath: decision.targetPath,
+                reason: decision.reason,
+            };
+            printSyncStatus(println, {
+                status: 'Skipped',
+                direction: 'pull',
+                targetPath: result.targetPath,
+                reason: result.reason,
+            });
+            return result;
+        }
+    }
+    const root = getWorkspaceRoot(cwd);
+    const folder = path.join(root, getComponentFolder(component));
+    const targetPath = path.relative(cwd, folder);
+    const elementsDir = path.join(folder, 'elements');
+    fs.mkdirSync(elementsDir, { recursive: true });
+    const extension = getDetailsExtension(component);
+    for (const element of component.elements || []) {
+        const content = element.details ?? element.logic ?? '';
+        const filePath = path.join(elementsDir, `${element.order}_${element.key}.${extension}`);
+        fs.writeFileSync(filePath, content);
+    }
+    writeJsonFile(path.join(folder, 'component.json'), stripDetails(component));
+    const result = {
+        status: 'pulled',
+        targetPath,
+        reason: decision.kind === 'skip' && decision.reason === 'stale version'
+            ? 'stale version'
+            : undefined,
+    };
+    printSyncStatus(println, {
+        status: 'Pulled',
+        direction: 'pull',
+        targetPath: result.targetPath,
+        reason: result.reason,
+    });
+    return result;
+}
+async function pullAllComponents(context, options) {
+    const { client, cwd } = context;
+    const components = [];
+    const seenRequests = new Set();
+    let nextRequest = {
+        query: {
+            take: COMPONENT_LIST_PAGE_SIZE,
+            skip: 0,
+        },
+    };
+    let discoveredTotal = null;
+    while (nextRequest) {
+        const requestKey = JSON.stringify(nextRequest);
+        if (seenRequests.has(requestKey)) {
+            throw new Error('Component list pagination loop detected while pulling all components.');
+        }
+        seenRequests.add(requestKey);
+        let pageValue;
+        try {
+            pageValue = await client.listComponents(nextRequest);
+        }
+        catch (error) {
+            rethrowComponentAccessError(error, 'list');
+        }
+        const page = unwrapComponentListPage(pageValue);
+        if (page.total !== null) {
+            discoveredTotal = page.total;
+        }
+        for (const item of page.items) {
+            if (isRecord(item)) {
+                components.push(item);
+            }
+        }
+        if (page.total !== null && components.length >= page.total) {
+            nextRequest = null;
+            continue;
+        }
+        if (page.nextRequest) {
+            nextRequest = page.nextRequest;
+            continue;
+        }
+        if (nextRequest.query
+            && typeof nextRequest.query.take === 'number'
+            && page.items.length === nextRequest.query.take) {
+            nextRequest = {
+                query: {
+                    take: nextRequest.query.take,
+                    skip: components.length,
+                },
+            };
+            continue;
+        }
+        nextRequest = null;
+    }
+    if (components.length === 0) {
+        context.println('No components found.');
+        return [];
+    }
+    await confirmBulkAction(context, 'pull', discoveredTotal ?? (components.length >= COMPONENT_LIST_PAGE_SIZE ? `at least ${components.length} components` : components.length), options.force);
+    const startedAt = Date.now();
+    const results = [];
+    for (const item of components) {
+        const componentId = item.componentId || item.id;
+        if (!componentId) {
+            continue;
+        }
+        const result = await pullSingleComponent(context, String(componentId), {
+            force: options.force,
+            stale: options.stale,
+            promptOnStale: false,
+        });
+        if (result) {
+            results.push(result);
+        }
+    }
+    printSummary(context.println, 'Pulled', results, Date.now() - startedAt);
+    return results;
+}
+async function pushSingleComponent(context, manifestPath) {
+    const { client, println } = context;
+    const component = readWorkspaceComponent(manifestPath);
+    const componentId = component.componentId || component.id;
+    const targetPath = componentWorkspacePath(context.cwd, manifestPath);
+    if (!componentId) {
+        throw new Error(`Missing componentId in ${manifestPath}.`);
+    }
+    if (!component.name) {
+        throw new Error(`Missing component name in ${manifestPath}.`);
+    }
+    const payload = {
+        componentId,
+        name: component.name,
+        category: normalizeCategoryForApi(manifestPath, component.category),
+        desc: component.desc,
+        type: normalizeComponentType(component),
+        active: component.active ?? true,
+        async: component.async ?? false,
+    };
+    const elements = (component.elements || []).map((element) => ({
+        key: element.key,
+        desc: element.desc,
+        details: element.details || '',
+        hidden: Boolean(element.hidden),
+        order: element.order,
+    }));
+    try {
+        const response = await client.saveComponentElements(componentId, elements);
+        if (response.status === 304) {
+            const result = {
+                status: 'skipped',
+                targetPath,
+                reason: 'no changes',
+            };
+            printSyncStatus(println, {
+                status: 'Skipped',
+                direction: 'push',
+                targetPath,
+                reason: result.reason,
+            });
+            return result;
+        }
+        const result = {
+            status: 'deployed',
+            targetPath,
+        };
+        printSyncStatus(println, {
+            status: 'Deployed',
+            direction: 'push',
+            targetPath,
+        });
+        return result;
+    }
+    catch (error) {
+        if (isNotModifiedError(error)) {
+            const result = {
+                status: 'skipped',
+                targetPath,
+                reason: 'no changes',
+            };
+            printSyncStatus(println, {
+                status: 'Skipped',
+                direction: 'push',
+                targetPath,
+                reason: result.reason,
+            });
+            return result;
+        }
+        if (error instanceof PermissionDeniedError) {
+            throw new Error('Access denied (403). You are authenticated, but you do not have permission to push components.');
+        }
+        if (error instanceof ApiError && error.status === 404) {
+            try {
+                await client.createComponent(payload);
+                await client.saveComponentElements(componentId, elements);
+            }
+            catch (createError) {
+                rethrowComponentAccessError(createError, 'push');
+            }
+            const result = {
+                status: 'deployed',
+                targetPath,
+            };
+            printSyncStatus(println, {
+                status: 'Deployed',
+                direction: 'push',
+                targetPath,
+            });
+            return result;
+        }
+        throw error;
+    }
+}
+async function pushAllComponents(context, options) {
+    const { cwd, println } = context;
+    const root = getWorkspaceRoot(cwd);
+    const manifests = getComponentManifestPaths(root);
+    if (manifests.length === 0) {
+        println(`No component.json files found in ${path.relative(cwd, root) || 'Components'}.`);
+        return [];
+    }
+    await confirmBulkAction(context, 'push', manifests.length, options.force);
+    const startedAt = Date.now();
+    const results = [];
+    for (const manifestPath of manifests) {
+        const result = await pushSingleComponent(context, manifestPath);
+        if (result) {
+            results.push(result);
+        }
+    }
+    printSummary(context.println, 'Deployed', results, Date.now() - startedAt);
+    return results;
+}
+function parseTargets(args, names) {
+    const values = readValues(args, names);
+    if (values.length > 0) {
+        return values;
+    }
+    return args._.slice(2);
+}
+function parseJsonObject(value, label) {
+    try {
+        const parsed = JSON.parse(value);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error(`${label} must be a JSON object.`);
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === `${label} must be a JSON object.`) {
+            throw error;
+        }
+        throw new Error(`${label} must be valid JSON.`);
+    }
+}
+function parseDebugInputs(args) {
+    const positionalBody = args._[3] || '';
+    const bodyFlag = readFlag(args, ['body', 'd']);
+    return parseJsonObject(positionalBody || bodyFlag || '{}', 'Debug inputs');
+}
+function parseDebugNumber(args, names, fallback, max, label) {
+    const raw = readFlag(args, names);
+    if (!raw) {
+        return fallback;
+    }
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value < 1 || value > max) {
+        throw new Error(`${label} must be an integer between 1 and ${max}.`);
+    }
+    return value;
+}
+function buildDebugElements(component) {
+    const componentId = component.componentId || component.id;
+    const componentName = component.name;
+    if (!componentId) {
+        throw new Error('Missing componentId in local manifest.');
+    }
+    if (!componentName) {
+        throw new Error('Missing component name in local manifest.');
+    }
+    return (component.elements || []).map((element) => {
+        const details = element.details || '';
+        return {
+            key: element.key,
+            desc: element.desc ?? null,
+            initValue: details,
+            details,
+            componentId,
+            componentName,
+            order: element.order,
+            hidden: Boolean(element.hidden),
+            uuid: typeof element.uuid === 'string' ? element.uuid : undefined,
+        };
+    });
+}
+async function debugSingleComponent(context, componentId) {
+    const manifests = findComponentManifestsById(context.cwd, componentId);
+    if (manifests.length === 0) {
+        throw new Error(`Unable to find local component for ${componentId}.`);
+    }
+    if (manifests.length > 1) {
+        throw new Error(`Multiple local components matched ${componentId}. Use a more specific component ID.`);
+    }
+    const manifestPath = manifests[0];
+    const component = readWorkspaceComponent(manifestPath);
+    const type = normalizeComponentType(component);
+    const inputs = parseDebugInputs(context.args);
+    const timeout = parseDebugNumber(context.args, ['timeout', 't'], 10, 600, 'Timeout');
+    const memory = parseDebugNumber(context.args, ['memory', 'm'], 128, 1024, 'Memory');
+    const profile = await context.client.me();
+    const sandboxEndpoint = extractSandboxEndpoint(profile);
+    if (!sandboxEndpoint) {
+        throw new Error('Authenticated profile did not include `endpoints.sandbox`, so component debug cannot run for this instance.');
+    }
+    const response = await context.client.debugComponent(buildSandboxDebugUrl(sandboxEndpoint), {
+        elements: buildDebugElements(component),
+        type,
+        inputs,
+        timeout,
+        memory,
+    });
+    context.print(response);
+}
+export async function handleComponentCommand(context) {
+    const { args } = context;
+    const subcommand = args._[1] || '';
+    const targets = parseTargets(args, ['id', 'i']);
+    const all = readFlag(args, ['all', 'a']) === 'true' || args.all === true || args.a === true;
+    const force = readBoolFlag(args, ['force', 'f']);
+    const stale = readBoolFlag(args, ['stale', 's']);
+    if (subcommand === 'pull-all') {
+        await pullAllComponents(context, { force, stale });
+        return;
+    }
+    if (subcommand === 'push-all') {
+        await pushAllComponents(context, { force });
+        return;
+    }
+    if (subcommand === 'debug') {
+        const componentId = args._[2] || readFlag(args, ['id', 'i']) || '';
+        if (!componentId) {
+            throw new Error('Missing component ID. Usage: `revo component debug <componentId> [-d <json>] [--timeout <seconds>] [--memory <mb>]`.');
+        }
+        await debugSingleComponent(context, componentId);
+        return;
+    }
+    if (subcommand === 'pull') {
+        if (!all && targets.length === 0) {
+            throw new Error('Provide --id <componentId> or --all.');
+        }
+        if (all) {
+            await pullAllComponents(context, { force, stale });
+            return;
+        }
+        for (const componentId of targets) {
+            await pullSingleComponent(context, componentId, { force, stale });
+        }
+        return;
+    }
+    if (subcommand === 'push') {
+        if (!all && targets.length === 0) {
+            throw new Error('Provide --id <componentId> or --all.');
+        }
+        if (all) {
+            await pushAllComponents(context, { force });
+            return;
+        }
+        const manifests = targets.flatMap((componentId) => findComponentManifestsById(context.cwd, componentId));
+        if (manifests.length === 0) {
+            throw new Error(`Unable to find local component for ${targets.join(', ')}.`);
+        }
+        for (const manifestPath of manifests) {
+            await pushSingleComponent(context, manifestPath);
+        }
+        return;
+    }
+    throw new Error('Unknown component command.');
+}