@burdenoff/bigconsole-cli 2026.802.1

package/dist/commands/parser.js

@@ -0,0 +1,181 @@
+/**
+ * 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);
+        }
+    });
+}

package/dist/commands/pipeline.d.ts

@@ -0,0 +1,5 @@
+/**
+ * pipeline commands — list, get, delete.
+ */
+import { Command } from 'commander';
+export declare function registerPipelineCommands(program: Command): void;

package/dist/commands/pipeline.js

@@ -0,0 +1,142 @@
+/**
+ * pipeline commands — list, get, 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 registerPipelineCommands(program) {
+    const p = program.command('pipeline').description('Pipeline operations');
+    p.command('list')
+        .description('List pipelines in the current workspace (scoped to a console)')
+        .requiredOption('--console <id>', 'Console (dashboard) ID pipelines belong to')
+        .option('--status <s>', 'Filter by status (active, draft, error, inactive)')
+        .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 {
+            // Canonical PipelineStatus enum values are lowercase — match schema exactly.
+            const VALID_STATUSES = new Set(['active', 'draft', 'error', 'inactive']);
+            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;
+            }
+            const d = await execWorkspace(ops.LIST_PIPELINES, { first: o.first ?? 25, after: o.after, filter });
+            const items = d.listPipelines.edges.map((e) => e.node);
+            formatAndOutput(o, items, {
+                headers: ['ID', 'Name', 'Status', 'Version', 'Last Executed', 'Updated'],
+                rows: items.map((x) => [
+                    truncate(x.id, 14),
+                    truncate(x.name, 28),
+                    formatStatus(x.status),
+                    String(x.version),
+                    formatDate(x.lastExecutedAt),
+                    formatDate(x.updatedAt),
+                ]),
+            });
+        }
+        catch (e) {
+            handleCommandError(e);
+        }
+    });
+    p.command('get')
+        .description('Get a pipeline by ID (includes stages)')
+        .argument('<id>')
+        .option('-f, --format <format>', 'Output format')
+        .action(async (id, o) => {
+        try {
+            const d = await execWorkspace(ops.GET_PIPELINE, { id });
+            if (!d.pipeline) {
+                printError('Pipeline not found');
+                process.exit(1);
+            }
+            formatAndOutput(o, d.pipeline);
+        }
+        catch (e) {
+            handleCommandError(e);
+        }
+    });
+    p.command('delete')
+        .description('Delete a pipeline')
+        .argument('<id>')
+        .action(async (id) => {
+        try {
+            await execWorkspace(ops.DELETE_PIPELINE, { id });
+            printSuccess(`Deleted pipeline ${id}`);
+        }
+        catch (e) {
+            handleCommandError(e);
+        }
+    });
+    p.command('create')
+        .description('Create a pipeline')
+        .requiredOption('--name <name>')
+        .requiredOption('--console <id>', 'Parent dashboard/console ID')
+        .option('--description <d>')
+        .option('--status <s>', 'Initial status (DRAFT | ACTIVE | ...)')
+        .option('--stages-file <path>', 'JSON file with array of CreatePipelineStageInput')
+        .option('--stages-json <json>', 'Inline JSON array for stages')
+        .option('-f, --format <format>', 'Output format')
+        .action(async (o) => {
+        try {
+            const stages = loadJsonInput(o.stagesFile, o.stagesJson);
+            const input = {
+                name: o.name,
+                consoleId: o.console,
+            };
+            if (o.description)
+                input.description = o.description;
+            if (o.status)
+                input.status = o.status.toUpperCase();
+            if (stages)
+                input.stages = stages;
+            const d = await execWorkspace(ops.CREATE_PIPELINE, {
+                input,
+            });
+            printSuccess(`Created pipeline: ${d.createPipeline.name} (${d.createPipeline.id})`);
+            formatAndOutput(o, d.createPipeline);
+        }
+        catch (e) {
+            handleCommandError(e);
+        }
+    });
+    p.command('update')
+        .description('Update a pipeline (requires current version)')
+        .argument('<id>')
+        .requiredOption('--version <n>', 'Current pipeline version', (v) => parseInt(v, 10))
+        .option('--name <n>')
+        .option('--description <d>')
+        .option('--status <s>')
+        .option('--stages-file <path>', 'JSON file with stages array to replace existing stages')
+        .option('--stages-json <json>', 'Inline JSON stages array')
+        .option('-f, --format <format>', 'Output format')
+        .action(async (id, o) => {
+        try {
+            const stages = loadJsonInput(o.stagesFile, o.stagesJson);
+            const input = {};
+            if (o.name)
+                input.name = o.name;
+            if (o.description !== undefined)
+                input.description = o.description;
+            if (o.status)
+                input.status = o.status.toUpperCase();
+            if (stages)
+                input.stages = stages;
+            const d = await execWorkspace(ops.UPDATE_PIPELINE, {
+                id,
+                version: o.version,
+                input,
+            });
+            printSuccess(`Updated pipeline ${id} (now v${d.updatePipeline.version})`);
+            formatAndOutput(o, d.updatePipeline);
+        }
+        catch (e) {
+            handleCommandError(e);
+        }
+    });
+}

package/dist/commands/prompt.d.ts

@@ -0,0 +1,5 @@
+/**
+ * prompt commands — AI-driven dashboard generation (generate, list, get, cancel).
+ */
+import { Command } from 'commander';
+export declare function registerPromptCommands(program: Command): void;

package/dist/commands/prompt.js

@@ -0,0 +1,84 @@
+/**
+ * prompt commands — AI-driven dashboard generation (generate, list, get, cancel).
+ */
+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 registerPromptCommands(program) {
+    const p = program.command('prompt').description('AI-driven dashboard generation');
+    p.command('generate')
+        .description('Start a new dashboard generation from a natural-language prompt')
+        .requiredOption('--prompt <text>', 'The natural-language prompt')
+        .option('--config-file <path>', 'Optional JSON with generation config')
+        .option('--config-json <json>', 'Optional inline JSON with generation config')
+        .option('-f, --format <format>', 'Output format')
+        .action(async (o) => {
+        try {
+            const extra = loadJsonInput(o.configFile, o.configJson) ?? {};
+            const input = { prompt: o.prompt, ...extra };
+            const d = await execWorkspace(ops.GENERATE_DASHBOARD_FROM_PROMPT, { input });
+            printSuccess(`Generation queued: ${d.generateDashboardFromPrompt.id}`);
+            formatAndOutput(o, d.generateDashboardFromPrompt);
+        }
+        catch (e) {
+            handleCommandError(e);
+        }
+    });
+    p.command('list')
+        .description('List prompt generations')
+        .option('--status <s>', 'Filter by status')
+        .option('--first <n>', 'Page size', (v) => parseInt(v, 10), 25)
+        .option('--after <cursor>')
+        .option('-f, --format <format>', 'Output format')
+        .action(async (o) => {
+        try {
+            const d = await execWorkspace(ops.LIST_PROMPT_GENERATIONS, {
+                first: o.first ?? 25,
+                after: o.after,
+                status: o.status ? o.status.toUpperCase() : undefined,
+            });
+            const items = d.listPromptGenerations.edges.map((e) => e.node);
+            formatAndOutput(o, items, {
+                headers: ['ID', 'Status', 'Prompt', 'Created'],
+                rows: items.map((x) => [
+                    truncate(x.id, 14),
+                    formatStatus(x.status),
+                    truncate(x.prompt, 50),
+                    formatDate(x.createdAt),
+                ]),
+            });
+        }
+        catch (e) {
+            handleCommandError(e);
+        }
+    });
+    p.command('get')
+        .description('Get a prompt generation by ID')
+        .argument('<id>')
+        .option('-f, --format <format>', 'Output format')
+        .action(async (id, o) => {
+        try {
+            const d = await execWorkspace(ops.GET_PROMPT_GENERATION, { id });
+            if (!d.getPromptGeneration) {
+                printError('Prompt generation not found');
+                process.exit(1);
+            }
+            formatAndOutput(o, d.getPromptGeneration);
+        }
+        catch (e) {
+            handleCommandError(e);
+        }
+    });
+    p.command('cancel')
+        .description('Cancel an in-flight prompt generation')
+        .argument('<id>')
+        .action(async (id) => {
+        try {
+            const d = await execWorkspace(ops.CANCEL_PROMPT_GENERATION, { id });
+            printSuccess(`Cancelled generation ${id} (status: ${d.cancelPromptGeneration.status})`);
+        }
+        catch (e) {
+            handleCommandError(e);
+        }
+    });
+}

package/dist/commands/share.d.ts

@@ -0,0 +1,8 @@
+/**
+ * share commands — list dashboard shares.
+ *
+ * Create / revoke are deferred until we have a clean UX for recipient
+ * selection (user/app/link token) + expiry.
+ */
+import { Command } from 'commander';
+export declare function registerShareCommands(program: Command): void;

package/dist/commands/share.js

@@ -0,0 +1,50 @@
+/**
+ * share commands — list dashboard shares.
+ *
+ * Create / revoke are deferred until we have a clean UX for recipient
+ * selection (user/app/link token) + expiry.
+ */
+import * as ops from '../graphql/operations.js';
+import { execWorkspace, formatAndOutput, handleCommandError } from './base.js';
+import { formatDate, truncate } from '../utils/output.js';
+export function registerShareCommands(program) {
+    const sh = program.command('share').description('Dashboard share management');
+    sh.command('list')
+        .description('List shares for a dashboard')
+        .requiredOption('--dashboard <id>', 'Dashboard ID')
+        .option('--active <bool>', 'Filter by active status')
+        .option('--permission <p>', 'Filter by permission (VIEW, EDIT, ...)')
+        .option('--recipient-type <t>', 'USER | APP | LINK')
+        .option('--first <n>', 'Page size', (v) => parseInt(v, 10), 25)
+        .option('--after <cursor>')
+        .option('-f, --format <format>', 'Output format')
+        .action(async (o) => {
+        try {
+            const d = await execWorkspace(ops.LIST_DASHBOARD_SHARES, {
+                dashboardId: o.dashboard,
+                first: o.first ?? 25,
+                after: o.after,
+                isActive: o.active === undefined
+                    ? undefined
+                    : o.active.toLowerCase() === 'true' || o.active === '1',
+                permission: o.permission ? o.permission.toUpperCase() : undefined,
+                recipientType: o.recipientType ? o.recipientType.toUpperCase() : undefined,
+            });
+            const items = d.listDashboardShares.edges.map((e) => e.node);
+            formatAndOutput(o, items, {
+                headers: ['ID', 'Dashboard', 'Permission', 'Active', 'Expires', 'Created'],
+                rows: items.map((x) => [
+                    truncate(x.id, 14),
+                    truncate(x.dashboardId, 14),
+                    x.permission,
+                    x.isActive ? 'yes' : 'no',
+                    formatDate(x.expiresAt),
+                    formatDate(x.createdAt),
+                ]),
+            });
+        }
+        catch (e) {
+            handleCommandError(e);
+        }
+    });
+}

package/dist/commands/template.d.ts

@@ -0,0 +1,5 @@
+/**
+ * template commands — list, get dashboard templates.
+ */
+import { Command } from 'commander';
+export declare function registerTemplateCommands(program: Command): void;

package/dist/commands/template.js

@@ -0,0 +1,62 @@
+/**
+ * template commands — list, get dashboard templates.
+ */
+import * as ops from '../graphql/operations.js';
+import { execWorkspace, formatAndOutput, handleCommandError } from './base.js';
+import { printError, formatDate, truncate } from '../utils/output.js';
+export function registerTemplateCommands(program) {
+    const t = program.command('template').description('Dashboard templates');
+    t.command('list')
+        .description('List dashboard templates')
+        .option('--search <term>')
+        .option('--category <c>')
+        .option('--featured', 'Only featured templates')
+        .option('--first <n>', 'Page size', (v) => parseInt(v, 10), 25)
+        .option('--after <cursor>')
+        .option('-f, --format <format>', 'Output format')
+        .action(async (o) => {
+        try {
+            const d = await execWorkspace(ops.LIST_TEMPLATES, {
+                first: o.first ?? 25,
+                after: o.after,
+                category: o.category ? o.category.toUpperCase() : undefined,
+                search: o.search,
+                isFeatured: o.featured ?? undefined,
+            });
+            const items = d.listTemplates.edges.map((e) => e.node);
+            formatAndOutput(o, items, {
+                headers: ['ID', 'Name', 'Category', 'Featured', 'Status', 'Created'],
+                rows: items.map((x) => [
+                    truncate(x.id, 14),
+                    truncate(x.name, 30),
+                    x.category,
+                    x.isFeatured ? '*' : '',
+                    x.status,
+                    formatDate(x.createdAt),
+                ]),
+            });
+        }
+        catch (e) {
+            handleCommandError(e);
+        }
+    });
+    t.command('get')
+        .description('Get a template by ID')
+        .argument('<id>')
+        .option('-f, --format <format>', 'Output format')
+        .action(async (id, o) => {
+        try {
+            const d = await execWorkspace(ops.GET_TEMPLATE, {
+                id,
+            });
+            if (!d.getTemplate) {
+                printError('Template not found');
+                process.exit(1);
+            }
+            formatAndOutput(o, d.getTemplate);
+        }
+        catch (e) {
+            handleCommandError(e);
+        }
+    });
+}

package/dist/commands/widget.d.ts

@@ -0,0 +1,5 @@
+/**
+ * widget commands — list by page, get, delete.
+ */
+import { Command } from 'commander';
+export declare function registerWidgetCommands(program: Command): void;