@liquidmetal-ai/raindrop 0.4.11 → 0.4.13

package/dist/commands/build/list.js

@@ -1,9 +1,10 @@
-import { ApplicationsResponseSchema, UnitState, } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/catalog_pb';
+import { toJsonString } from '@bufbuild/protobuf';
 import { timestampDate } from '@bufbuild/protobuf/wkt';
+import { ApplicationsResponseSchema, UnitState, } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/catalog_pb';
 import { Flags } from '@oclif/core';
+import chalk from 'chalk';
 import { BaseCommand } from '../../base-command.js';
 import { EPOCH_TS } from '../../index.js';
-import { toJsonString } from '@bufbuild/protobuf';
 export const statusString = {
     [UnitState.UNSPECIFIED]: '<unknown>',
     [UnitState.PENDING]: 'pending...',
@@ -18,8 +19,20 @@ export default class List extends BaseCommand {
     static args = {};
     static description = 'list Raindrop catalog resources';
     static examples = [
-        `<%= config.bin %> <%= command.id %> .
-List Raindrop catalog resources.
+        `<%= config.bin %> <%= command.id %>
+List applications in compact view (default).
+
+<%= config.bin %> <%= command.id %> -o tree
+Show applications in tree view with version hierarchy.
+
+<%= config.bin %> <%= command.id %> -o log
+Show git-log style view with branch visualization.
+
+<%= config.bin %> <%= command.id %> --app demo-fts --limit 5
+Show only demo-fts application, limited to 5 versions.
+
+<%= config.bin %> <%= command.id %> --active
+Show only running/active versions.
 `,
     ];
     static flags = {
@@ -28,8 +41,21 @@ List Raindrop catalog resources.
         output: Flags.string({
             char: 'o',
             description: 'output format',
-            default: 'table',
-            options: ['text', 'table', 'json', 'log'],
+            default: 'compact',
+            options: ['text', 'table', 'json', 'log', 'compact', 'tree'],
+        }),
+        app: Flags.string({
+            description: 'filter by application name',
+            required: false,
+        }),
+        limit: Flags.integer({
+            char: 'n',
+            description: 'limit number of versions shown per application',
+            required: false,
+        }),
+        active: Flags.boolean({
+            description: 'show only running/active versions',
+            default: false,
         }),
         impersonate: Flags.string({
             char: 'i',
@@ -77,121 +103,277 @@ List Raindrop catalog resources.
     }
     // Render the version tree in git-log style with branch lines
     renderGitLogStyle(applications) {
-        // Build the version tree first
-        const { rootNodes } = this.buildVersionTree(applications);
-        // Track columns for each branch in the graph
-        const columnMap = new Map();
-        let maxColumn = 0;
-        // Function to assign columns to each node in the tree
-        const assignColumns = (node, parentColumn) => {
-            if (columnMap.has(node.versionId))
-                return;
-            // If parent has a column, try to use the same column
-            if (parentColumn !== undefined) {
-                columnMap.set(node.versionId, parentColumn);
+        const groups = this.groupApplicationsByName(applications);
+        const result = [];
+        // Process each application group separately
+        for (const [appName, appVersions] of groups) {
+            result.push('');
+            result.push(chalk.bold.underline(`=== ${appName} ===`));
+            result.push('');
+            // Build the version tree for this app
+            const { rootNodes } = this.buildVersionTree(appVersions);
+            // Track columns for each branch in the graph
+            const columnMap = new Map();
+            let maxColumn = 0;
+            // Function to assign columns to each node in the tree
+            const assignColumns = (node, parentColumn) => {
+                if (columnMap.has(node.versionId))
+                    return;
+                // If parent has a column, try to use the same column
+                if (parentColumn !== undefined) {
+                    columnMap.set(node.versionId, parentColumn);
+                }
+                else {
+                    // Assign a new column for this branch
+                    columnMap.set(node.versionId, maxColumn++);
+                }
+                // Recursively assign columns to children
+                node.children.forEach((child) => {
+                    assignColumns(child, columnMap.get(node.versionId));
+                });
+            };
+            // Assign columns to all nodes starting from roots
+            rootNodes.forEach((root) => assignColumns(root));
+            // Flatten tree for display in chronological order
+            const flattenedNodes = [];
+            const flatten = (node) => {
+                flattenedNodes.push(node);
+                node.children.forEach((child) => flatten(child));
+            };
+            rootNodes.forEach((root) => flatten(root));
+            // Sort flattened nodes by timestamp (newest first)
+            flattenedNodes.sort((a, b) => {
+                const aTime = timestampDate(a.application.createdAt || EPOCH_TS).getTime() || 0;
+                const bTime = timestampDate(b.application.createdAt || EPOCH_TS).getTime() || 0;
+                return bTime - aTime;
+            });
+            // Generate graph lines
+            const processed = new Set();
+            const linesInUse = new Set();
+            for (const node of flattenedNodes) {
+                if (processed.has(node.versionId))
+                    continue;
+                processed.add(node.versionId);
+                const app = node.application;
+                const column = columnMap.get(node.versionId) || 0;
+                linesInUse.add(column);
+                // Format timestamp like git
+                const date = timestampDate(app.createdAt || EPOCH_TS);
+                const timestamp = date.toLocaleString('en-US', {
+                    weekday: 'short',
+                    month: 'short',
+                    day: 'numeric',
+                    year: 'numeric',
+                    hour: 'numeric',
+                    minute: 'numeric',
+                    second: 'numeric',
+                    hour12: false,
+                    timeZoneName: 'short',
+                });
+                // Create graph line with asterisk at current position
+                let graphLine = '';
+                for (let i = 0; i <= maxColumn; i++) {
+                    if (i === column) {
+                        graphLine += '*';
+                    }
+                    else if (linesInUse.has(i)) {
+                        graphLine += '|';
+                    }
+                    else {
+                        graphLine += ' ';
+                    }
+                }
+                // Add branch indicator if available
+                let branchInfo = '';
+                if (app.branch) {
+                    branchInfo = ` (${app.branch})`;
+                }
+                // Add previous version info if available
+                let parentInfo = '';
+                if (app.previousVersionId) {
+                    parentInfo = ` [parent: ${app.previousVersionId}]`;
+                }
+                // Format output lines with color
+                const versionLine = `${graphLine} ${chalk.yellow('version')} ${chalk.yellow(app.versionId)}${chalk.cyan(branchInfo)}${chalk.dim(parentInfo)}`;
+                result.push(versionLine);
+                // Replace asterisk with pipe for continuation lines
+                graphLine = graphLine.replace('*', '|');
+                // Show additional metadata indented like git log
+                let statusColor;
+                if (app.state === UnitState.RUNNING) {
+                    statusColor = chalk.green;
+                }
+                else if (app.state === UnitState.DELETING) {
+                    statusColor = chalk.yellow;
+                }
+                else if (app.state === UnitState.DELETED) {
+                    statusColor = chalk.red;
+                }
+                else {
+                    statusColor = chalk.gray;
+                }
+                result.push(`${graphLine} ${chalk.bold('Status:')} ${statusColor(statusString[app.state])}`);
+                result.push(`${graphLine} ${chalk.bold('Date:')}   ${chalk.dim(timestamp)}`);
+                result.push(`${graphLine} `);
+                result.push(`${graphLine}     ${chalk.bold(app.name)}`);
+                result.push(`${graphLine}`);
             }
-            else {
-                // Assign a new column for this branch
-                columnMap.set(node.versionId, maxColumn++);
+        }
+        return result.join('\n');
+    }
+    // Group applications by name
+    groupApplicationsByName(applications) {
+        const groups = new Map();
+        for (const app of applications) {
+            const name = app.name;
+            if (!groups.has(name)) {
+                groups.set(name, []);
             }
-            // Recursively assign columns to children
-            node.children.forEach((child) => {
-                assignColumns(child, columnMap.get(node.versionId));
+            groups.get(name).push(app);
+        }
+        // Sort each group by date (newest first)
+        for (const apps of groups.values()) {
+            apps.sort((a, b) => {
+                const aTime = timestampDate(a.createdAt || EPOCH_TS).getTime();
+                const bTime = timestampDate(b.createdAt || EPOCH_TS).getTime();
+                return bTime - aTime;
             });
-        };
-        // Assign columns to all nodes starting from roots
-        rootNodes.forEach((root) => assignColumns(root));
-        // Generate the graph output
+        }
+        return groups;
+    }
+    // Render compact view
+    renderCompactView(applications) {
+        const groups = this.groupApplicationsByName(applications);
         const result = [];
-        // Flatten tree for display in chronological order
-        const flattenedNodes = [];
-        const flatten = (node) => {
-            flattenedNodes.push(node);
-            node.children.forEach((child) => flatten(child));
-        };
-        rootNodes.forEach((root) => flatten(root));
-        // Sort flattened nodes by timestamp (newest first)
-        flattenedNodes.sort((a, b) => {
-            const aTime = timestampDate(a.application.createdAt || EPOCH_TS).getTime() || 0;
-            const bTime = timestampDate(b.application.createdAt || EPOCH_TS).getTime() || 0;
+        // Sort groups by most recent activity
+        const sortedGroups = Array.from(groups.entries()).sort((a, b) => {
+            const aLatest = a[1][0];
+            const bLatest = b[1][0];
+            if (!aLatest || !bLatest)
+                return 0;
+            const aTime = timestampDate(aLatest.createdAt || EPOCH_TS).getTime();
+            const bTime = timestampDate(bLatest.createdAt || EPOCH_TS).getTime();
             return bTime - aTime;
         });
-        // Generate graph lines
-        const processed = new Set();
-        const linesInUse = new Set();
-        for (const node of flattenedNodes) {
-            if (processed.has(node.versionId))
-                continue;
-            processed.add(node.versionId);
-            const app = node.application;
-            const column = columnMap.get(node.versionId) || 0;
-            linesInUse.add(column);
-            // Format timestamp like git
-            const date = timestampDate(app.createdAt || EPOCH_TS);
-            const timestamp = date.toLocaleString('en-US', {
-                weekday: 'short',
-                month: 'short',
-                day: 'numeric',
-                year: 'numeric',
-                hour: 'numeric',
-                minute: 'numeric',
-                second: 'numeric',
-                hour12: false,
-                timeZoneName: 'short',
-            });
-            // Create graph line with asterisk at current position
-            let graphLine = '';
-            for (let i = 0; i <= maxColumn; i++) {
-                if (i === column) {
-                    graphLine += '*';
+        for (const [appName, versions] of sortedGroups) {
+            const activeVersions = versions.filter(v => v.state === UnitState.RUNNING);
+            const deletedVersions = versions.filter(v => v.state === UnitState.DELETED || v.state === UnitState.DELETING);
+            result.push(`\n${chalk.bold(appName)} ${chalk.dim(`(${versions.length} version${versions.length !== 1 ? 's' : ''})`)}`);
+            // Show active versions first
+            let shown = 0;
+            for (const version of activeVersions) {
+                if (this.flags.limit && shown >= this.flags.limit)
+                    break;
+                const date = timestampDate(version.createdAt || EPOCH_TS).toLocaleDateString();
+                const branch = version.branch ? chalk.cyan(` (${version.branch})`) : '';
+                const status = chalk.green(statusString[version.state]);
+                result.push(`  └─ ${chalk.yellow(version.versionId)}...${branch} - ${status} - ${chalk.dim(date)}`);
+                shown++;
+            }
+            // Show some deleted versions if not --active flag
+            if (!this.flags.active && deletedVersions.length > 0) {
+                const remaining = this.flags.limit ? Math.max(0, this.flags.limit - shown) : deletedVersions.length;
+                const toShow = Math.min(remaining, deletedVersions.length);
+                for (let i = 0; i < toShow && i < 3; i++) {
+                    const version = deletedVersions[i];
+                    if (!version)
+                        continue;
+                    const date = timestampDate(version.createdAt || EPOCH_TS).toLocaleDateString();
+                    const status = version.state === UnitState.DELETING ? chalk.yellow(statusString[version.state]) : chalk.red(statusString[version.state]);
+                    result.push(`  └─ ${chalk.gray(version.versionId)}... - ${status} - ${chalk.dim(date)}`);
+                }
+                if (deletedVersions.length > toShow) {
+                    result.push(chalk.dim(`  ... ${deletedVersions.length - toShow} more deleted versions`));
+                }
+            }
+        }
+        // Add summary at the end
+        const totalApps = sortedGroups.length;
+        const totalVersions = applications.length;
+        const activeVersions = applications.filter(app => app.state === UnitState.RUNNING).length;
+        result.push('');
+        result.push(chalk.dim('─'.repeat(50)));
+        result.push(chalk.dim(`Total: ${totalApps} applications, ${totalVersions} versions (${activeVersions} active)`));
+        return result.join('\n');
+    }
+    // Render tree view for a specific application
+    renderTreeView(applications) {
+        const groups = this.groupApplicationsByName(applications);
+        const result = [];
+        for (const [appName, versions] of groups) {
+            result.push(`\n${chalk.bold.underline(`=== ${appName} ===`)}`);
+            // Build version tree for this app
+            const { rootNodes } = this.buildVersionTree(versions);
+            // Render each root and its descendants
+            const renderNode = (node, prefix = '', isLast = true) => {
+                const app = node.application;
+                const date = timestampDate(app.createdAt || EPOCH_TS).toLocaleDateString();
+                const branch = app.branch ? chalk.cyan(` (${app.branch})`) : '';
+                let status;
+                if (app.state === UnitState.RUNNING) {
+                    status = chalk.green(statusString[app.state]);
+                }
+                else if (app.state === UnitState.DELETING) {
+                    status = chalk.yellow(statusString[app.state]);
                 }
-                else if (linesInUse.has(i)) {
-                    graphLine += '|';
+                else if (app.state === UnitState.DELETED) {
+                    status = chalk.red(statusString[app.state]);
                 }
                 else {
-                    graphLine += ' ';
+                    status = chalk.gray(statusString[app.state]);
                 }
-            }
-            // Add branch indicator if available
-            let branchInfo = '';
-            if (app.branch) {
-                branchInfo = ` (${app.branch})`;
-            }
-            // Add previous version info if available
-            let parentInfo = '';
-            if (app.previousVersionId) {
-                const parentShortId = app.previousVersionId.substring(0, 8);
-                parentInfo = ` [parent: ${parentShortId}]`;
-            }
-            // Format output lines
-            result.push(`${graphLine} version ${app.versionId}${branchInfo}${parentInfo}`);
-            // Replace asterisk with pipe for continuation lines
-            graphLine = graphLine.replace('*', '|');
-            // Show additional metadata indented like git log
-            const status = statusString[app.state];
-            result.push(`${graphLine} Status: ${status}`);
-            result.push(`${graphLine} Date:   ${timestamp}`);
-            result.push(`${graphLine} `);
-            result.push(`${graphLine}     ${app.name}`);
-            result.push(`${graphLine}`);
+                const current = app.state === UnitState.RUNNING && app.branch === 'main' ? chalk.bold.green(' ← current') : '';
+                const connector = isLast ? '└─' : '├─';
+                const shortId = chalk.yellow(app.versionId);
+                result.push(`${prefix}${connector} ${shortId}...${branch} - ${status} - ${chalk.dim(date)}${current}`);
+                // Render children
+                const childPrefix = prefix + (isLast ? '   ' : '│  ');
+                node.children.forEach((child, index) => {
+                    renderNode(child, childPrefix, index === node.children.length - 1);
+                });
+            };
+            rootNodes.forEach((root, index) => {
+                renderNode(root, '', index === rootNodes.length - 1);
+            });
         }
         return result.join('\n');
     }
     async listApplications() {
         const { client: catalogService, organizationId: defaultOrganizationId, userId } = await this.catalogService();
         const organizationId = this.flags.impersonate ?? defaultOrganizationId;
-        this.log(`Listing applications for organization ${organizationId}`);
+        // Only show the "Listing applications..." message for certain outputs
+        if (this.flags.output === 'log' || this.flags.output === 'table') {
+            this.log(chalk.dim(`Listing applications for organization ${organizationId}`));
+        }
         const resp = await catalogService.applications({
             userId,
             organizationId,
             showDeleted: this.flags.all,
         });
+        // Apply filters
+        let applications = resp.applications;
+        // Filter by app name if specified
+        if (this.flags.app) {
+            applications = applications.filter(app => app.name === this.flags.app);
+        }
+        // Filter by active status if specified
+        if (this.flags.active) {
+            applications = applications.filter(app => app.state === UnitState.RUNNING);
+        }
         if (this.flags.output === 'log') {
             // Process and display in git-log style with branch lines
-            this.log(this.renderGitLogStyle(resp.applications));
+            this.log(this.renderGitLogStyle(applications));
+        }
+        else if (this.flags.output === 'compact') {
+            // Display compact view
+            this.log(this.renderCompactView(applications));
+        }
+        else if (this.flags.output === 'tree') {
+            // Display tree view
+            this.log(this.renderTreeView(applications));
         }
         else if (this.flags.output === 'table') {
-            console.table(resp.applications.reduce(
+            console.table(applications.reduce(
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             (acc, a) => {
                 const dateStr = a.createdAt ? timestampDate(a.createdAt).toISOString() : '';
@@ -209,9 +391,8 @@ List Raindrop catalog resources.
             console.log(toJsonString(ApplicationsResponseSchema, resp, { prettySpaces: 2 }));
         }
         else {
-            for (const a of resp.applications) {
-                console.log(`${timestampDate(a.createdAt || EPOCH_TS).toISOString()} ${a.organizationId} ${a.versionId} ${a.name} (${a.isActive ? 'active' : 'inactive'}, ${statusString[a.state]}, ${a.lock ? 'locked' : 'unlocked'})`);
-            }
+            // Default to compact view
+            this.log(this.renderCompactView(applications));
         }
     }
     async run() {

package/dist/commands/build/status.d.ts

@@ -1,6 +1,4 @@
-import { StatusResponse, UnitState } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/catalog_pb';
 import { BaseCommand } from '../../base-command.js';
-export declare const statusString: Record<UnitState, string>;
 export default class Status extends BaseCommand<typeof Status> {
     static args: {};
     static description: string;
@@ -22,7 +20,5 @@ export default class Status extends BaseCommand<typeof Status> {
         sendVersionMetadata: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
-    linesLastRendered: number;
-    renderLive(status: StatusResponse): Promise<void>;
 }
 //# sourceMappingURL=status.d.ts.map

package/dist/commands/build/status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/commands/build/status.ts"],"names":[],"mappings":"AACA,OAAO,EACL,cAAc,EAEd,SAAS,EACV,MAAM,yDAAyD,CAAC;AAKjE,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CASzC,CAAC;AAEX,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,WAAW,CAAC,OAAO,MAAM,CAAC;IAC5D,MAAM,CAAC,IAAI,KAAM;IAEjB,MAAM,CAAC,WAAW,SAAmD;IAErE,MAAM,CAAC,QAAQ,WAGb;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;MAsCV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;IAgE1B,iBAAiB,SAAK;IAEhB,UAAU,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CA6BxD"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/commands/build/status.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGpD,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,WAAW,CAAC,OAAO,MAAM,CAAC;IAC5D,MAAM,CAAC,IAAI,KAAM;IAEjB,MAAM,CAAC,WAAW,SAAmD;IAErE,MAAM,CAAC,QAAQ,WAGb;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;MAsCV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAoD3B"}

package/dist/commands/build/status.js

@@ -1,20 +1,9 @@
-import { valueOf } from '@liquidmetal-ai/drizzle/appify/build';
-import { StatusResponseSchema, UnitState, } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/catalog_pb';
-import { Flags, ux } from '@oclif/core';
-import Table from 'cli-table3';
-import * as readline from 'readline';
 import { toJsonString } from '@bufbuild/protobuf';
+import { StatusResponseSchema } from '@liquidmetal-ai/drizzle/liquidmetal/v1alpha1/catalog_pb';
+import { Flags } from '@oclif/core';
+import Table from 'cli-table3';
 import { BaseCommand } from '../../base-command.js';
-export const statusString = {
-    [UnitState.UNSPECIFIED]: '<unknown>',
-    [UnitState.PENDING]: 'pending...',
-    [UnitState.STARTING]: 'starting...',
-    [UnitState.RUNNING]: 'running',
-    [UnitState.STOPPING]: 'stopping...',
-    [UnitState.STOPPED]: 'stopped',
-    [UnitState.DELETING]: 'deleting...',
-    [UnitState.DELETED]: 'deleted',
-};
+import { getStatus, StatusRenderer, statusString, watchStatus } from '../../status.js';
 export default class Status extends BaseCommand {
     static args = {};
     static description = 'show the status of an application in Raindrop';
@@ -44,8 +33,8 @@ export default class Status extends BaseCommand {
         output: Flags.string({
             char: 'o',
             description: 'output format',
-            default: 'table',
-            options: ['watch', 'table', 'json'],
+            default: 'compact',
+            options: ['watch', 'table', 'json', 'compact'],
         }),
         sudo: Flags.boolean({
             char: 's',
@@ -62,89 +51,50 @@ export default class Status extends BaseCommand {
         }),
     };
     async run() {
-        const { flags } = await this.parse(Status);
-        if (!flags.version) {
-            const config = await this.loadConfig();
-            flags.version = config.versionId;
-        }
-        if (!flags.application) {
-            const apps = await this.loadManifest();
-            const app = apps[0];
-            if (app === undefined) {
-                this.error('No application provided or found in manifest', { exit: 1 });
-            }
-            flags.application = valueOf(app.name);
-        }
-        const { client: catalogService, userId, organizationId: defaultOrganizationId } = await this.catalogService();
-        const organizationId = flags.impersonate ?? defaultOrganizationId;
-        const applicationStatus = await catalogService.status({
-            userId,
-            organizationId,
+        const flags = (await this.parse(Status)).flags;
+        const status = await getStatus({
+            command: this,
+            root: flags.root,
+            manifest: flags.manifest,
             applicationName: flags.application,
-            currentVersionId: flags.version || '',
+            versionId: flags.version,
+            impersonate: flags.impersonate,
         });
-        if (applicationStatus === undefined) {
-            this.error(`Application ${flags.application} not found`, { exit: 1 });
+        if (flags.output === 'compact') {
+            // Get application name and version for display
+            const applicationName = flags.application || (await this.loadManifest())[0]?.name.value || 'unknown';
+            const versionId = flags.version || (await this.loadConfig()).versionId;
+            const renderer = new StatusRenderer();
+            renderer.renderCompact(status, applicationName, versionId);
+            return;
         }
         if (flags.output === 'table') {
             // Display the status of each module in the application using console.table
-            const statusTable = applicationStatus.modules.map((module) => ({
+            const statusTable = status.modules.map((module) => ({
                 module: module.name,
                 status: statusString[module.state],
-                urls: module.urls.join(', '),
+                message: module.notification || ''
             }));
             const table = new Table({
                 head: ['Module', 'Status', 'URLs'],
             });
-            table.push(...statusTable.map((row) => [row.module, row.status, row.urls]));
+            table.push(...statusTable.map((row) => [row.module, row.status, row.message || '']));
             console.log(table.toString());
             return;
         }
         if (flags.output === 'json') {
-            console.log(toJsonString(StatusResponseSchema, applicationStatus, { prettySpaces: 2 }));
+            console.log(toJsonString(StatusResponseSchema, status, { prettySpaces: 2 }));
             return;
         }
-        let watchStatus = applicationStatus;
         if (flags.output === 'watch') {
-            while (true) {
-                await this.renderLive(watchStatus);
-                if (watchStatus.state === UnitState.RUNNING || watchStatus.state === UnitState.STOPPED) {
-                    break;
-                }
-                await new Promise((resolve) => setTimeout(resolve, 1000));
-                watchStatus = await catalogService.status({
-                    userId,
-                    organizationId,
-                    applicationName: flags.application,
-                    currentVersionId: flags.version || '',
-                });
-            }
-        }
-    }
-    linesLastRendered = 0;
-    async renderLive(status) {
-        if (this.linesLastRendered > 0) {
-            readline.moveCursor(process.stdout, 0, -this.linesLastRendered);
-            readline.clearScreenDown(process.stdout);
-        }
-        const lines = [];
-        const statusStateString = (state) => ux.colorize({
-            [UnitState.UNSPECIFIED]: 'gray',
-            [UnitState.PENDING]: 'gray',
-            [UnitState.STARTING]: 'yellow',
-            [UnitState.RUNNING]: 'green',
-            [UnitState.STOPPING]: 'yellow',
-            [UnitState.STOPPED]: 'red',
-            [UnitState.DELETING]: 'gray',
-            [UnitState.DELETED]: 'gray',
-        }[state], statusString[state]);
-        for (const module of status.modules) {
-            const padding = ' '.repeat(32 - module.name.length);
-            lines.push(`${padding}${module.name}: ${statusStateString(module.state)} ${module.urls.join(', ')}`);
-        }
-        for (const line of lines) {
-            console.log(line);
+            await watchStatus({
+                command: this,
+                root: flags.root,
+                manifest: flags.manifest,
+                applicationName: flags.application,
+                versionId: flags.version,
+                impersonate: flags.impersonate,
+            });
         }
-        this.linesLastRendered = lines.length;
     }
 }

package/dist/commands/object/delete.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/commands/object/delete.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAIpD,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,WAAW,CAAC,OAAO,YAAY,CAAC;IACxE,MAAM,CAAC,IAAI;;MAKT;IAEF,MAAM,CAAC,WAAW,SAA2C;IAE7D,MAAM,CAAC,QAAQ,WAIb;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;;;;MA+BV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CA0C3B"}
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/commands/object/delete.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,WAAW,CAAC,OAAO,YAAY,CAAC;IACxE,MAAM,CAAC,IAAI;;MAKT;IAEF,MAAM,CAAC,WAAW,SAA2C;IAE7D,MAAM,CAAC,QAAQ,WAIb;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;;;;MA+BV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CA2C3B"}