@burdenoff/bigconsole-cli 2026.1029.1 → 2026.1110.1

package/dist/commands/dashboard.js

@@ -1,223 +0,0 @@
-/**
- * dashboard commands — list, get, archive, delete.
- */
-import { readFileSync, writeFileSync } from 'fs';
-import * as ops from '../graphql/operations.js';
-import { execWorkspace, formatAndOutput, handleCommandError, loadJsonInput } from './base.js';
-import { printSuccess, printError, formatDate, formatStatus, truncate } from '../utils/output.js';
-import { sanitizeForTerminal } from '../utils/sanitize.js';
-export function registerDashboardCommands(program) {
-    const dash = program.command('dashboard').description('Dashboard operations');
-    dash
-        .command('list')
-        .description('List dashboards in the current workspace')
-        .option('--search <term>', 'Search by name')
-        .option('--category <c>', 'Filter by category')
-        .option('--visibility <v>', 'PRIVATE | WORKSPACE | PUBLIC')
-        .option('--include-archived', 'Include archived dashboards')
-        .option('--first <n>', 'Page size', (v) => parseInt(v, 10), 25)
-        .option('--after <cursor>', 'Cursor for next page')
-        .option('-f, --format <format>', 'Output format')
-        .action(async (o) => {
-        try {
-            const d = await execWorkspace(ops.LIST_DASHBOARDS, {
-                first: o.first ?? 25,
-                after: o.after,
-                search: o.search,
-                category: o.category ? o.category.toUpperCase() : undefined,
-                visibility: o.visibility ? o.visibility.toUpperCase() : undefined,
-                includeArchived: o.includeArchived ?? false,
-            });
-            const items = d.listDashboards.edges.map((e) => e.node);
-            formatAndOutput(o, items, {
-                headers: ['ID', 'Name', 'Status', 'Visibility', 'Category', 'Updated'],
-                rows: items.map((x) => [
-                    truncate(x.id, 14),
-                    truncate(x.name, 30),
-                    formatStatus(x.status),
-                    x.visibility,
-                    x.category,
-                    formatDate(x.updatedAt),
-                ]),
-            });
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    dash
-        .command('get')
-        .description('Get a dashboard by ID')
-        .argument('<id>')
-        .option('-f, --format <format>', 'Output format')
-        .action(async (id, o) => {
-        try {
-            const d = await execWorkspace(ops.GET_DASHBOARD, {
-                id,
-            });
-            if (!d.getDashboard) {
-                printError('Dashboard not found');
-                process.exit(1);
-            }
-            formatAndOutput(o, d.getDashboard);
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    dash
-        .command('archive')
-        .description('Archive a dashboard (soft-delete, can be restored)')
-        .argument('<id>')
-        .action(async (id) => {
-        try {
-            const d = await execWorkspace(ops.ARCHIVE_DASHBOARD, {
-                id,
-            });
-            printSuccess(`Archived: ${d.archiveDashboard.name} (${d.archiveDashboard.id})`);
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    dash
-        .command('delete')
-        .description('Permanently delete a dashboard')
-        .argument('<id>')
-        .action(async (id) => {
-        try {
-            await execWorkspace(ops.DELETE_DASHBOARD, { id });
-            printSuccess(`Deleted dashboard ${id}`);
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    dash
-        .command('create')
-        .description('Create a dashboard')
-        .requiredOption('--name <name>', 'Dashboard name')
-        .requiredOption('--category <cat>', 'Category (e.g. ANALYTICS, OPERATIONS)')
-        .option('--description <d>', 'Description')
-        .option('--visibility <v>', 'PRIVATE | WORKSPACE | PUBLIC', 'PRIVATE')
-        .option('--layout <l>', 'GRID | FREEFORM', 'GRID')
-        .option('--no-default-page', 'Skip creating the default page')
-        .option('--metadata-file <path>', 'JSON file with custom metadata')
-        .option('--metadata-json <json>', 'Inline JSON for custom metadata')
-        .option('-f, --format <format>', 'Output format')
-        .action(async (o) => {
-        try {
-            const metadata = loadJsonInput(o.metadataFile, o.metadataJson);
-            const input = {
-                name: o.name,
-                category: o.category.toUpperCase(),
-                description: o.description,
-                visibility: (o.visibility ?? 'PRIVATE').toUpperCase(),
-                layout: (o.layout ?? 'GRID').toUpperCase(),
-                createDefaultPage: o.defaultPage !== false,
-                metadata,
-            };
-            const d = await execWorkspace(ops.CREATE_DASHBOARD, { input });
-            printSuccess(`Created dashboard: ${d.createBigConsoleDashboard.name} (${d.createBigConsoleDashboard.id})`);
-            formatAndOutput(o, d.createBigConsoleDashboard);
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    dash
-        .command('update')
-        .description('Update a dashboard')
-        .argument('<id>')
-        .option('--name <name>')
-        .option('--description <d>')
-        .option('--category <cat>')
-        .option('--visibility <v>', 'PRIVATE | WORKSPACE | PUBLIC')
-        .option('--layout <l>', 'GRID | FREEFORM')
-        .option('-f, --format <format>', 'Output format')
-        .action(async (id, o) => {
-        try {
-            const input = { id };
-            if (o.name)
-                input.name = o.name;
-            if (o.description !== undefined)
-                input.description = o.description;
-            if (o.category)
-                input.category = o.category.toUpperCase();
-            if (o.visibility)
-                input.visibility = o.visibility.toUpperCase();
-            if (o.layout)
-                input.layout = o.layout.toUpperCase();
-            const d = await execWorkspace(ops.UPDATE_DASHBOARD, { input });
-            printSuccess(`Updated dashboard ${id}`);
-            formatAndOutput(o, d.updateBigConsoleDashboard);
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    dash
-        .command('import')
-        .description('Import a dashboard from a JSON file (dashboard definition)')
-        .requiredOption('--file <path>', 'Dashboard JSON file produced by `dashboard export`')
-        .option('--name <name>', 'Override dashboard name')
-        .option('--visibility <v>', 'Override visibility: PRIVATE | WORKSPACE | PUBLIC')
-        .option('--conflict <strategy>', 'Conflict resolution: RENAME | REPLACE | FAIL', 'RENAME')
-        .action(async (o) => {
-        try {
-            const json = readFileSync(o.file, 'utf8');
-            const input = {
-                json,
-                conflictResolution: (o.conflict ?? 'RENAME').toUpperCase(),
-            };
-            if (o.name)
-                input.name = o.name;
-            if (o.visibility)
-                input.visibility = o.visibility.toUpperCase();
-            const d = await execWorkspace(ops.IMPORT_DASHBOARD, {
-                input,
-            });
-            printSuccess(`Imported dashboard: ${d.importDashboard.name} (${d.importDashboard.id})`);
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    dash
-        .command('export')
-        .description('Export a dashboard definition as JSON (stdout or --out file)')
-        .argument('<id>')
-        .option('--out <path>', 'Write JSON to file instead of stdout')
-        .option('--include-data-refs', 'Include data source references', true)
-        .option('--include-webhook-mappings', 'Include webhook mappings')
-        .option('--pretty', 'Pretty-print JSON', true)
-        .action(async (id, o) => {
-        try {
-            const options = {
-                includeDataSourceRefs: o.includeDataRefs !== false,
-                includeWebhookMappings: o.includeWebhookMappings ?? false,
-                prettyPrint: o.pretty !== false,
-            };
-            const d = await execWorkspace(ops.EXPORT_DASHBOARD, {
-                id,
-                options,
-            });
-            if (o.out) {
-                writeFileSync(o.out, d.exportDashboard, 'utf8');
-                printSuccess(`Exported to ${o.out}`);
-            }
-            else {
-                // Byte-exact when piped or redirected; made inert for a terminal.
-                const body = process.stdout.isTTY
-                    ? sanitizeForTerminal(d.exportDashboard, { preserveNewlines: true })
-                    : d.exportDashboard;
-                process.stdout.write(body);
-                if (!body.endsWith('\n'))
-                    process.stdout.write('\n');
-            }
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-}

package/dist/commands/datasink.js

@@ -1,175 +0,0 @@
-/**
- * datasink commands — list, get (by id OR key), fetch data, delete.
- */
-import * as ops from '../graphql/operations.js';
-import { execWorkspace, formatAndOutput, handleCommandError, loadJsonInput } from './base.js';
-import { printSuccess, printError, formatDate, formatStatus, truncate } from '../utils/output.js';
-export function registerDataSinkCommands(program) {
-    const ds = program.command('datasink').description('DataSink operations');
-    ds.command('list')
-        .description('List DataSinks in the current workspace')
-        .option('--search <term>', 'Search by name')
-        .option('--status <s>', 'Filter by status')
-        .option('--setup-state <s>', 'Filter by setup state')
-        .option('--active <bool>', 'Filter by isActive (true/false)')
-        .option('--first <n>', 'Page size', (v) => parseInt(v, 10), 25)
-        .option('--after <cursor>', 'Cursor for next page')
-        .option('-f, --format <format>', 'Output format')
-        .action(async (o) => {
-        try {
-            const d = await execWorkspace(ops.LIST_DATASINKS, {
-                first: o.first ?? 25,
-                after: o.after,
-                search: o.search,
-                status: o.status ? o.status.toUpperCase() : undefined,
-                setupState: o.setupState ? o.setupState.toUpperCase() : undefined,
-                isActive: o.active === undefined
-                    ? undefined
-                    : o.active.toLowerCase() === 'true' || o.active === '1',
-            });
-            const items = d.listDataSinks.edges.map((e) => e.node);
-            formatAndOutput(o, items, {
-                headers: ['ID', 'Name', 'Key', 'Status', 'Setup', 'Active', 'Updated'],
-                rows: items.map((x) => [
-                    truncate(x.id, 14),
-                    truncate(x.name ?? '-', 24),
-                    truncate(x.key, 20),
-                    formatStatus(x.status),
-                    x.setupState,
-                    x.isActive ? 'yes' : 'no',
-                    formatDate(x.updatedAt),
-                ]),
-            });
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    ds.command('get')
-        .description('Get a DataSink by ID or key')
-        .option('--id <id>', 'DataSink ID')
-        .option('--key <key>', 'DataSink key')
-        .option('-f, --format <format>', 'Output format')
-        .action(async (o) => {
-        try {
-            if (!o.id && !o.key) {
-                printError('Provide --id or --key');
-                process.exit(1);
-            }
-            const d = await execWorkspace(ops.GET_DATASINK, {
-                id: o.id,
-                key: o.key,
-            });
-            if (!d.getDataSink) {
-                printError('DataSink not found');
-                process.exit(1);
-            }
-            formatAndOutput(o, d.getDataSink);
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    ds.command('data')
-        .description('Fetch the current data payload of a DataSink')
-        .option('--id <id>', 'DataSink ID')
-        .option('--key <key>', 'DataSink key')
-        .option('--path <p>', 'JSONPath-like filter (e.g. items[0].value)')
-        .option('--force-refresh', 'Bypass cache')
-        .option('-f, --format <format>', 'Output format (json recommended)')
-        .action(async (o) => {
-        try {
-            if (!o.id && !o.key) {
-                printError('Provide --id or --key');
-                process.exit(1);
-            }
-            const d = await execWorkspace(ops.GET_DATASINK_DATA, {
-                id: o.id,
-                key: o.key,
-                dataPath: o.path,
-                forceRefresh: o.forceRefresh ?? false,
-            });
-            formatAndOutput({ format: o.format ?? 'json' }, d.getDataSinkData);
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    ds.command('delete')
-        .description('Delete a DataSink')
-        .argument('<id>')
-        .action(async (id) => {
-        try {
-            await execWorkspace(ops.DELETE_DATASINK, { id });
-            printSuccess(`Deleted DataSink ${id}`);
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    ds.command('create')
-        .description('Create a DataSink')
-        .requiredOption('--key <key>', 'Unique key within workspace (e.g. sales_metrics_q4)')
-        .option('--name <name>', 'Display name')
-        .option('--description <d>', 'Description')
-        .option('--data-file <path>', 'JSON file with initial payload')
-        .option('--data-json <json>', 'Inline JSON for initial payload')
-        .option('--config-file <path>', 'JSON file with DataSink config')
-        .option('--config-json <json>', 'Inline JSON for DataSink config')
-        .option('-f, --format <format>', 'Output format')
-        .action(async (o) => {
-        try {
-            const data = loadJsonInput(o.dataFile, o.dataJson);
-            const config = loadJsonInput(o.configFile, o.configJson);
-            const input = { key: o.key };
-            if (o.name)
-                input.name = o.name;
-            if (o.description)
-                input.description = o.description;
-            if (data !== undefined)
-                input.data = data;
-            if (config !== undefined)
-                input.config = config;
-            const d = await execWorkspace(ops.CREATE_DATASINK, {
-                input,
-            });
-            printSuccess(`Created DataSink: ${d.createDataSink.key} (${d.createDataSink.id})`);
-            formatAndOutput(o, d.createDataSink);
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    ds.command('update')
-        .description('Update a DataSink')
-        .argument('<id>')
-        .option('--name <name>')
-        .option('--description <d>')
-        .option('--active <bool>', 'true / false')
-        .option('--data-file <path>', 'JSON file to replace data payload')
-        .option('--data-json <json>', 'Inline JSON to replace data payload')
-        .option('-f, --format <format>', 'Output format')
-        .action(async (id, o) => {
-        try {
-            const data = loadJsonInput(o.dataFile, o.dataJson);
-            const input = { id };
-            if (o.name)
-                input.name = o.name;
-            if (o.description !== undefined)
-                input.description = o.description;
-            if (o.active !== undefined) {
-                input.isActive = o.active.toLowerCase() === 'true' || o.active === '1';
-            }
-            if (data !== undefined)
-                input.data = data;
-            const d = await execWorkspace(ops.UPDATE_DATASINK, {
-                input,
-            });
-            printSuccess(`Updated DataSink ${id}`);
-            formatAndOutput(o, d.updateDataSink);
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-}

package/dist/commands/drilldown.js

@@ -1,55 +0,0 @@
-/**
- * drilldown commands — list actions on a widget, delete drilldown config.
- *
- * Drilldown creation is JSON-heavy (parameter mappings, target routes,
- * modal/push/replace navigation). It's deferred to a future pass where we
- * can offer a generator-style UX rather than a flag firehose.
- */
-import * as ops from '../graphql/operations.js';
-import { execWorkspace, formatAndOutput, handleCommandError } from './base.js';
-import { printSuccess, formatDate, truncate } from '../utils/output.js';
-export function registerDrilldownCommands(program) {
-    const dd = program.command('drilldown').description('Widget drilldown actions');
-    dd.command('list')
-        .description('List widget actions (includes drilldowns)')
-        .requiredOption('--widget <id>', 'Widget ID')
-        .option('-f, --format <format>', 'Output format')
-        .action(async (o) => {
-        try {
-            const d = await execWorkspace(ops.GET_WIDGET_ACTIONS, { widgetId: o.widget });
-            formatAndOutput(o, d.getWidgetActions, {
-                headers: ['ID', 'Widget', 'Type', 'Label', 'Created'],
-                rows: d.getWidgetActions.map((a) => [
-                    truncate(a.id, 14),
-                    truncate(a.widgetId, 14),
-                    a.type,
-                    truncate(a.label ?? '-', 24),
-                    formatDate(a.createdAt),
-                ]),
-            });
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    dd.command('delete')
-        .description('Delete the drilldown configuration from a widget')
-        .requiredOption('--widget <id>', 'Widget ID')
-        .action(async (o) => {
-        try {
-            // deleteWidgetDrilldown takes the drilldown's own id; resolve it from the widget.
-            const lookup = await execWorkspace(ops.GET_WIDGET_DRILLDOWN, {
-                id: o.widget,
-            });
-            const drilldownId = lookup.getWidget?.drilldown?.id;
-            if (!drilldownId) {
-                throw new Error(`Widget ${o.widget} has no drilldown configuration`);
-            }
-            await execWorkspace(ops.DELETE_WIDGET_DRILLDOWN, { id: drilldownId });
-            printSuccess(`Removed drilldown from widget ${o.widget}`);
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-}

package/dist/commands/index.js

@@ -1,13 +0,0 @@
-export { registerAuthCommands } from './auth.js';
-export { registerCLIConfigCommands } from './cli-config.js';
-export { registerWorkspaceCommands } from './workspace.js';
-export { registerDashboardCommands } from './dashboard.js';
-export { registerWidgetCommands } from './widget.js';
-export { registerDataSinkCommands } from './datasink.js';
-export { registerParserCommands } from './parser.js';
-export { registerPipelineCommands } from './pipeline.js';
-export { registerWorkflowCommands } from './workflow.js';
-export { registerDrilldownCommands } from './drilldown.js';
-export { registerShareCommands } from './share.js';
-export { registerTemplateCommands } from './template.js';
-export { registerPromptCommands } from './prompt.js';

package/dist/commands/parser.js

@@ -1,181 +0,0 @@
-/**
- * parser commands — list, get, delete.
- */
-import * as ops from '../graphql/operations.js';
-import { execWorkspace, formatAndOutput, handleCommandError, loadTextInput } from './base.js';
-import { printSuccess, printError, formatDate, formatStatus, truncate } from '../utils/output.js';
-export function registerParserCommands(program) {
-    const p = program.command('parser').description('Parser operations');
-    p.command('list')
-        .description('List parsers in the current workspace (scoped to a console)')
-        .requiredOption('--console <id>', 'Console (dashboard) ID parsers belong to')
-        .option('--status <s>', 'Filter by status (active, inactive)')
-        .option('--type <t>', 'Filter by parser type (jq, jsonata, spark)')
-        .option('--input <sinkKey>', 'Filter by input sink key')
-        .option('--first <n>', 'Page size', (v) => parseInt(v, 10), 25)
-        .option('--after <cursor>', 'Cursor for next page')
-        .option('-f, --format <format>', 'Output format')
-        .action(async (o) => {
-        try {
-            // Parser resolvers are scoped per-console, not per-workspace.
-            // Canonical enum values are lowercase — match server schema exactly.
-            const VALID_STATUSES = new Set(['active', 'inactive']);
-            const VALID_TYPES = new Set(['jq', 'jsonata', 'spark']);
-            const filter = { consoleId: o.console };
-            if (o.status) {
-                const s = o.status.toLowerCase();
-                if (!VALID_STATUSES.has(s)) {
-                    printError(`Invalid --status "${o.status}". Valid: ${[...VALID_STATUSES].join(', ')}`);
-                    process.exit(1);
-                }
-                filter.status = s;
-            }
-            if (o.type) {
-                const t = o.type.toLowerCase();
-                if (!VALID_TYPES.has(t)) {
-                    printError(`Invalid --type "${o.type}". Valid: ${[...VALID_TYPES].join(', ')}`);
-                    process.exit(1);
-                }
-                filter.type = t;
-            }
-            if (o.input)
-                filter.inputSinkKey = o.input;
-            const d = await execWorkspace(ops.LIST_PARSERS, { first: o.first ?? 25, after: o.after, filter });
-            const items = d.listParsers.edges.map((e) => e.node);
-            formatAndOutput(o, items, {
-                headers: ['ID', 'Name', 'Type', 'Status', 'Input', 'Output', 'Updated'],
-                rows: items.map((x) => [
-                    truncate(x.id, 14),
-                    truncate(x.name, 24),
-                    x.type,
-                    formatStatus(x.status),
-                    truncate(x.inputSinkKey, 18),
-                    truncate(x.outputKey, 18),
-                    formatDate(x.updatedAt),
-                ]),
-            });
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    p.command('get')
-        .description('Get a parser by ID (includes the expression body)')
-        .argument('<id>')
-        .option('-f, --format <format>', 'Output format')
-        .action(async (id, o) => {
-        try {
-            const d = await execWorkspace(ops.GET_PARSER, { id });
-            if (!d.parser) {
-                printError('Parser not found');
-                process.exit(1);
-            }
-            formatAndOutput(o, d.parser);
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    p.command('delete')
-        .description('Delete a parser')
-        .argument('<id>')
-        .action(async (id) => {
-        try {
-            await execWorkspace(ops.DELETE_PARSER, { id });
-            printSuccess(`Deleted parser ${id}`);
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    p.command('create')
-        .description('Create a parser')
-        .requiredOption('--name <name>')
-        .requiredOption('--console <id>', 'Parent dashboard/console ID')
-        .requiredOption('--input-key <key>', 'DataSink key this parser reads from')
-        .requiredOption('--output-key <key>', 'Key for parser output (used by widgets)')
-        .requiredOption('--type <t>', 'Parser type (JQ, JSONATA, ...)')
-        .option('--expression <expr>', 'Parser expression (inline)')
-        .option('--expression-file <path>', 'Parser expression from file')
-        .option('--description <d>')
-        .option('--output-widget <id>', 'Target widget ID (v2.1)')
-        .option('--ttl <seconds>', 'Cache TTL', (v) => parseInt(v, 10))
-        .option('-f, --format <format>', 'Output format')
-        .action(async (o) => {
-        try {
-            const expression = loadTextInput(o.expressionFile, o.expression);
-            if (!expression) {
-                printError('Provide --expression or --expression-file');
-                process.exit(1);
-            }
-            const input = {
-                name: o.name,
-                consoleId: o.console,
-                inputSinkKey: o.inputKey,
-                outputKey: o.outputKey,
-                type: o.type.toUpperCase(),
-                expression,
-            };
-            if (o.description)
-                input.description = o.description;
-            if (o.outputWidget)
-                input.outputWidgetId = o.outputWidget;
-            if (o.ttl !== undefined)
-                input.ttl = o.ttl;
-            const d = await execWorkspace(ops.CREATE_PARSER, {
-                input,
-            });
-            printSuccess(`Created parser: ${d.createParser.name} (${d.createParser.id})`);
-            formatAndOutput(o, d.createParser);
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-    p.command('update')
-        .description('Update a parser (requires current version for optimistic concurrency)')
-        .argument('<id>')
-        .requiredOption('--version <n>', 'Current parser version', (v) => parseInt(v, 10))
-        .option('--name <n>')
-        .option('--description <d>')
-        .option('--input-key <k>')
-        .option('--output-key <k>')
-        .option('--output-widget <id>')
-        .option('--status <s>', 'Parser status')
-        .option('--expression <expr>')
-        .option('--expression-file <path>')
-        .option('--ttl <seconds>', '', (v) => parseInt(v, 10))
-        .option('-f, --format <format>', 'Output format')
-        .action(async (id, o) => {
-        try {
-            const expression = loadTextInput(o.expressionFile, o.expression);
-            const input = {};
-            if (o.name)
-                input.name = o.name;
-            if (o.description !== undefined)
-                input.description = o.description;
-            if (o.inputKey)
-                input.inputSinkKey = o.inputKey;
-            if (o.outputKey)
-                input.outputKey = o.outputKey;
-            if (o.outputWidget)
-                input.outputWidgetId = o.outputWidget;
-            if (o.status)
-                input.status = o.status.toUpperCase();
-            if (expression)
-                input.expression = expression;
-            if (o.ttl !== undefined)
-                input.ttl = o.ttl;
-            const d = await execWorkspace(ops.UPDATE_PARSER, {
-                id,
-                version: o.version,
-                input,
-            });
-            printSuccess(`Updated parser ${id} (now v${d.updateParser.version})`);
-            formatAndOutput(o, d.updateParser);
-        }
-        catch (e) {
-            handleCommandError(e);
-        }
-    });
-}