vigthoria-cli 1.6.8 → 1.6.9

package/dist/commands/workflow.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowCommand = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const api_js_1 = require("../utils/api.js");
+class WorkflowCommand {
+    config;
+    logger;
+    api;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+        this.api = new api_js_1.APIClient(config, logger);
+    }
+    ensureAuthenticated(json = false) {
+        if (this.config.isAuthenticated()) {
+            return;
+        }
+        const message = 'Not authenticated. Run vigthoria login first.';
+        if (json) {
+            console.log(JSON.stringify({ success: false, error: message }, null, 2));
+        }
+        else {
+            this.logger.error(message);
+        }
+        throw new Error(message);
+    }
+    parseJsonOption(rawValue, fieldName) {
+        if (!rawValue) {
+            return {};
+        }
+        try {
+            const parsed = JSON.parse(rawValue);
+            if (!parsed || Array.isArray(parsed) || typeof parsed !== 'object') {
+                throw new Error(`${fieldName} must be a JSON object.`);
+            }
+            return parsed;
+        }
+        catch (error) {
+            throw new Error(`Invalid ${fieldName} JSON: ${error.message}`);
+        }
+    }
+    printJson(payload) {
+        console.log(JSON.stringify(payload, null, 2));
+    }
+    async templates(options) {
+        this.ensureAuthenticated(Boolean(options.json));
+        const templates = await this.api.listVigFlowTemplates({
+            category: options.category,
+            search: options.search,
+        });
+        if (options.json) {
+            this.printJson({ success: true, templates });
+            return;
+        }
+        this.logger.section('Workflow Templates');
+        if (templates.length === 0) {
+            console.log(chalk_1.default.yellow('No templates matched your filters.'));
+            return;
+        }
+        this.logger.table(['ID', 'Name', 'Category', 'Tags'], templates.map((template) => [
+            template.id,
+            template.name,
+            template.category,
+            (template.tags || []).slice(0, 3).join(', '),
+        ]));
+    }
+    async list(options) {
+        this.ensureAuthenticated(Boolean(options.json));
+        const workflows = await this.api.listVigFlowWorkflows();
+        if (options.json) {
+            this.printJson({ success: true, workflows });
+            return;
+        }
+        this.logger.section('Workflows');
+        if (workflows.length === 0) {
+            console.log(chalk_1.default.yellow('No workflows found for this account.'));
+            return;
+        }
+        this.logger.table(['ID', 'Name', 'Nodes', 'Runs', 'Updated'], workflows.map((workflow) => [
+            workflow.id,
+            workflow.name,
+            String(workflow.nodeCount),
+            String(workflow.executionCount),
+            workflow.updatedAt ? new Date(workflow.updatedAt).toLocaleString() : '-',
+        ]));
+    }
+    async useTemplate(templateId, options) {
+        this.ensureAuthenticated(Boolean(options.json));
+        const variables = this.parseJsonOption(options.variables, 'variables');
+        const workflow = await this.api.useVigFlowTemplate(templateId, {
+            name: options.name,
+            variables,
+        });
+        if (options.json) {
+            this.printJson({ success: true, workflow });
+            return;
+        }
+        this.logger.success(`Created workflow ${workflow.name}`);
+        console.log(chalk_1.default.gray(`Workflow ID: ${workflow.id}`));
+        if (workflow.fromTemplate) {
+            console.log(chalk_1.default.gray(`Template: ${workflow.fromTemplate}`));
+        }
+    }
+    async run(workflowId, options) {
+        this.ensureAuthenticated(Boolean(options.json));
+        const data = this.parseJsonOption(options.data, 'data');
+        const execution = await this.api.runVigFlowWorkflow(workflowId, { data });
+        if (options.json) {
+            this.printJson({ success: true, execution });
+            return;
+        }
+        this.logger.success(`Workflow execution ${execution.status}`);
+        console.log(chalk_1.default.gray(`Execution ID: ${execution.executionId}`));
+        console.log(chalk_1.default.gray(`Nodes executed: ${execution.nodesExecuted ?? 0}`));
+        if (execution.error) {
+            console.log(chalk_1.default.red(execution.error));
+        }
+    }
+    async status(executionId, options) {
+        this.ensureAuthenticated(Boolean(options.json));
+        const execution = await this.api.getVigFlowExecutionStatus(executionId);
+        if (options.json) {
+            this.printJson({ success: true, execution });
+            return;
+        }
+        this.logger.box([
+            `Execution: ${execution.id}`,
+            `Workflow: ${execution.workflowId}`,
+            `Status: ${execution.status}`,
+            `Nodes: ${execution.nodesExecuted ?? 0}/${execution.totalNodes ?? '-'}`,
+            `Started: ${execution.startedAt || '-'}`,
+            `Completed: ${execution.completedAt || '-'}`,
+        ].join('\n'), 'Workflow Status');
+    }
+}
+exports.WorkflowCommand = WorkflowCommand;

package/dist/index.d.ts

@@ -12,6 +12,7 @@
  *   vigthoria login             - Authenticate with Vigthoria
  *   vigthoria config            - Configure settings
  *   vigthoria hub               - Discover & activate API modules
+ *   vigthoria workflow          - Manage repeatable VigFlow workflows
+ *   vigthoria operator          - Start BMAD operator mode
  */
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -13,6 +13,8 @@
  *   vigthoria login             - Authenticate with Vigthoria
  *   vigthoria config            - Configure settings
  *   vigthoria hub               - Discover & activate API modules
+ *   vigthoria workflow          - Manage repeatable VigFlow workflows
+ *   vigthoria operator          - Start BMAD operator mode
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -62,6 +64,8 @@ const review_js_1 = require("./commands/review.js");
 const hub_js_1 = require("./commands/hub.js");
 const repo_js_1 = require("./commands/repo.js");
 const deploy_js_1 = require("./commands/deploy.js");
+const bridge_js_1 = require("./commands/bridge.js");
+const workflow_js_1 = require("./commands/workflow.js");
 const config_js_2 = require("./utils/config.js");
 const logger_js_1 = require("./utils/logger.js");
 const chalk_1 = __importDefault(require("chalk"));
@@ -94,7 +98,7 @@ function getVersion() {
     catch (e) {
         // Fallback to hardcoded version
     }
-    return '1.6.8';
+    return '1.6.9';
 }
 const VERSION = getVersion();
 /**
@@ -150,10 +154,11 @@ async function main() {
     const logger = new logger_js_1.Logger();
     const invokedBinaryName = getInvokedBinaryName();
     const firstArg = process.argv[2];
+    const jsonOutputRequested = process.argv.includes('--json');
     if (invokedBinaryName === 'vigthoria-chat') {
         const knownCommands = new Set([
             'chat', 'chat-resume', 'agent', 'edit', 'generate', 'explain', 'fix', 'review',
-            'hub', 'repo', 'deploy', 'login', 'logout', 'status', 'config', 'update',
+            'hub', 'repo', 'deploy', 'operator', 'workflow', 'flow', 'login', 'logout', 'status', 'config', 'update',
             '--help', '-h', '--version', '-V', 'help', 'version',
         ]);
         if (!firstArg || firstArg.startsWith('-') || !knownCommands.has(firstArg)) {
@@ -167,15 +172,19 @@ async function main() {
     // Calculate padding for centering
     const titlePad = Math.floor((boxWidth - 4 - titleText.length) / 2);
     const versionPad = Math.floor((boxWidth - 4 - versionText.length) / 2);
-    console.log(chalk_1.default.cyan('╔' + '═'.repeat(boxWidth) + '╗'));
-    console.log(chalk_1.default.cyan('║' + ' '.repeat(boxWidth) + '║'));
-    console.log(chalk_1.default.cyan('║') + ' '.repeat(titlePad) + chalk_1.default.bold.white('VIGTHORIA CLI') + chalk_1.default.cyan(' - AI-Powered Coding Assistant') + ' '.repeat(boxWidth - titlePad - titleText.length) + chalk_1.default.cyan('║'));
-    console.log(chalk_1.default.cyan('║') + ' '.repeat(versionPad) + chalk_1.default.gray(versionText) + ' '.repeat(boxWidth - versionPad - versionText.length) + chalk_1.default.cyan('║'));
-    console.log(chalk_1.default.cyan('║' + ' '.repeat(boxWidth) + '║'));
-    console.log(chalk_1.default.cyan('╚' + '═'.repeat(boxWidth) + '╝'));
-    console.log();
+    if (process.env.VIGTHORIA_NO_BANNER !== '1' && !jsonOutputRequested) {
+        console.log(chalk_1.default.cyan('╔' + '═'.repeat(boxWidth) + '╗'));
+        console.log(chalk_1.default.cyan('║' + ' '.repeat(boxWidth) + '║'));
+        console.log(chalk_1.default.cyan('║') + ' '.repeat(titlePad) + chalk_1.default.bold.white('VIGTHORIA CLI') + chalk_1.default.cyan(' - AI-Powered Coding Assistant') + ' '.repeat(boxWidth - titlePad - titleText.length) + chalk_1.default.cyan('║'));
+        console.log(chalk_1.default.cyan('║') + ' '.repeat(versionPad) + chalk_1.default.gray(versionText) + ' '.repeat(boxWidth - versionPad - versionText.length) + chalk_1.default.cyan('║'));
+        console.log(chalk_1.default.cyan('║' + ' '.repeat(boxWidth) + '║'));
+        console.log(chalk_1.default.cyan('╚' + '═'.repeat(boxWidth) + '╝'));
+        console.log();
+    }
     // Check for updates in background (don't wait)
-    checkForUpdatesQuietly();
+    if (process.env.VIGTHORIA_NO_UPDATE_CHECK !== '1' && !jsonOutputRequested) {
+        checkForUpdatesQuietly();
+    }
     program
         .name(invokedBinaryName === 'vigthoria-chat' ? 'vigthoria-chat' : 'vigthoria')
         .description('AI-powered terminal coding assistant for Vigthoria Coder subscribers')
@@ -191,6 +200,8 @@ async function main() {
         .option('--no-agent', 'Disable agentic mode (simple chat only)')
         .option('-r, --resume', 'Resume last session for this project', false)
         .option('--prompt <text>', 'Run a single prompt directly and exit')
+        .option('-w, --workflow <selector>', 'Route prompts through a named or explicit VigFlow workflow target')
+        .option('--json', 'Emit machine-readable JSON output for direct prompt runs', false)
         .option('--auto-approve', 'Auto-approve agent actions (dangerous!)', false)
         .action(async (options) => {
         const chat = new chat_js_1.ChatCommand(config, logger);
@@ -198,6 +209,8 @@ async function main() {
             model: options.model,
             project: options.project,
             agent: options.agent,
+            workflow: options.workflow,
+            json: options.json,
             autoApprove: options.autoApprove,
             resume: options.resume,
             prompt: options.prompt,
@@ -211,6 +224,8 @@ async function main() {
         .option('-a, --agent', 'Enable agentic mode (default: true for best quality)', true)
         .option('--no-agent', 'Disable agentic mode (simple chat only)')
         .option('--prompt <text>', 'Run a single prompt directly and exit after resuming context')
+        .option('-w, --workflow <selector>', 'Route prompts through a named or explicit VigFlow workflow target')
+        .option('--json', 'Emit machine-readable JSON output for direct prompt runs', false)
         .option('--auto-approve', 'Auto-approve agent actions (dangerous!)', false)
         .action(async (options) => {
         const chat = new chat_js_1.ChatCommand(config, logger);
@@ -218,6 +233,8 @@ async function main() {
             model: options.model,
             project: options.project,
             agent: options.agent,
+            workflow: options.workflow,
+            json: options.json,
             autoApprove: options.autoApprove,
             resume: true,
             prompt: options.prompt,
@@ -232,6 +249,8 @@ async function main() {
         .option('-m, --model <model>', 'Select AI model (agent, code, cloud, ultra)', 'agent')
         .option('-p, --project <path>', 'Set project context path', process.cwd())
         .option('--prompt <text>', 'Run a single agent prompt directly and exit')
+        .option('-w, --workflow <selector>', 'Run the prompt through a named or explicit VigFlow workflow target')
+        .option('--json', 'Emit machine-readable JSON output for direct prompt runs', false)
         .option('--auto-approve', 'Auto-approve all actions (dangerous!)', false)
         .action(async (options) => {
         const chat = new chat_js_1.ChatCommand(config, logger);
@@ -239,10 +258,45 @@ async function main() {
             model: options.model,
             project: options.project,
             agent: true,
+            operator: false,
+            workflow: options.workflow,
+            json: options.json,
             autoApprove: options.autoApprove,
             prompt: options.prompt,
         });
     });
+    program
+        .command('operator')
+        .alias('op')
+        .description('Start BMAD operator mode for infrastructure and system workflows')
+        .option('-m, --model <model>', 'Select operator model (code-8b, code, agent)', 'code-8b')
+        .option('-p, --project <path>', 'Set project context path', process.cwd())
+        .option('--prompt <text>', 'Run a single operator prompt directly and exit')
+        .option('-w, --workflow <selector>', 'Run the prompt through a named or explicit VigFlow workflow target')
+        .option('--save-plan', 'Save the completed BMAD plan into VigFlow for rerun and audit', false)
+        .option('--json', 'Emit machine-readable JSON output for direct prompt runs', false)
+        .action(async (options) => {
+        const chat = new chat_js_1.ChatCommand(config, logger);
+        await chat.run({
+            model: options.model,
+            project: options.project,
+            agent: false,
+            operator: true,
+            workflow: options.workflow,
+            savePlan: options.savePlan,
+            json: options.json,
+            prompt: options.prompt,
+        });
+    });
+    program
+        .command('bridge')
+        .description('Inspect local DevTools Bridge availability for browser debugging tasks')
+        .command('status')
+        .description('Show live DevTools Bridge status')
+        .action(async () => {
+        const bridge = new bridge_js_1.BridgeCommand(config, logger);
+        await bridge.status();
+    });
     // Edit command - Edit files with AI
     program
         .command('edit <file>')
@@ -299,6 +353,61 @@ async function main() {
         const review = new review_js_1.ReviewCommand(config, logger);
         await review.run(file, options);
     });
+    const workflowCommand = program
+        .command('workflow')
+        .alias('flow')
+        .description('List, instantiate, and run repeatable VigFlow workflows');
+    workflowCommand
+        .command('templates')
+        .alias('catalog')
+        .description('List available VigFlow templates')
+        .option('-c, --category <category>', 'Filter templates by category')
+        .option('-s, --search <query>', 'Search template names, descriptions, and tags')
+        .option('--json', 'Emit machine-readable JSON output', false)
+        .action(async (options) => {
+        const workflow = new workflow_js_1.WorkflowCommand(config, logger);
+        await workflow.templates(options);
+    });
+    workflowCommand
+        .command('list')
+        .alias('ls')
+        .description('List workflows created for the current account')
+        .option('--json', 'Emit machine-readable JSON output', false)
+        .action(async (options) => {
+        const workflow = new workflow_js_1.WorkflowCommand(config, logger);
+        await workflow.list(options);
+    });
+    workflowCommand
+        .command('use-template <templateId>')
+        .description('Create a workflow from a built-in or saved template')
+        .option('-n, --name <name>', 'Override the workflow name')
+        .option('-v, --variables <json>', 'Template variables as a JSON object')
+        .option('--json', 'Emit machine-readable JSON output', false)
+        .action(async (templateId, options) => {
+        const workflow = new workflow_js_1.WorkflowCommand(config, logger);
+        await workflow.useTemplate(templateId, options);
+    });
+    workflowCommand
+        .command('run <workflowId>')
+        .description('Run a workflow immediately')
+        .option('-d, --data <json>', 'Execution input data as a JSON object')
+        .option('--json', 'Emit machine-readable JSON output', false)
+        .action(async (workflowId, options) => {
+        const workflow = new workflow_js_1.WorkflowCommand(config, logger);
+        await workflow.run(workflowId, options);
+    });
+    workflowCommand
+        .command('status <executionId>')
+        .description('Get the current or final status of a workflow execution')
+        .option('--json', 'Emit machine-readable JSON output', false)
+        .action(async (executionId, options) => {
+        const workflow = new workflow_js_1.WorkflowCommand(config, logger);
+        await workflow.status(executionId, options);
+    });
+    workflowCommand.action(async () => {
+        const workflow = new workflow_js_1.WorkflowCommand(config, logger);
+        await workflow.templates({});
+    });
     // ==================== HUB / MARKETPLACE COMMANDS ====================
     // Hub command - Discover and activate API modules
     const hubCommand = program
@@ -620,4 +729,3 @@ main().catch((err) => {
     console.error(chalk_1.default.red('Error:'), err.message);
     process.exit(1);
 });
-//# sourceMappingURL=index.js.map

package/dist/utils/api.d.ts

@@ -21,10 +21,59 @@ export interface ChatResponse {
 export interface V3AgentWorkflowResponse {
     content: string;
     taskId: string | null;
+    contextId?: string | null;
     backendUrl: string;
     partial?: boolean;
     metadata?: Record<string, unknown>;
 }
+export interface FrontendPreviewGateResult {
+    required: boolean;
+    passed: boolean;
+    backendUrl?: string;
+    entryPath?: string;
+    assetPaths?: {
+        css: string[];
+        js: string[];
+    };
+    artifacts?: {
+        manifestPath?: string;
+        screenshotPath?: string;
+        previewFileUrl?: string;
+        screenshotCaptured?: boolean;
+        screenshotError?: string;
+    };
+    modes?: {
+        design?: {
+            ready: boolean;
+            devices?: string[];
+            variantCount?: number;
+        };
+        live?: {
+            ready: boolean;
+            entryPoint?: string;
+        };
+        production?: {
+            ready: boolean;
+            deploymentTarget?: string;
+            recommendedCommand?: string;
+        };
+    };
+    summary?: Record<string, unknown>;
+    processingTimeMs?: number;
+    error?: string;
+}
+export interface OperatorWorkflowResponse {
+    content: string;
+    workflowId: string | null;
+    contextId?: string | null;
+    backendUrl: string;
+    savedWorkflow?: {
+        id: string;
+        name?: string | null;
+        sourceWorkflowId?: string | null;
+    } | null;
+    metadata?: Record<string, unknown>;
+}
 export interface StreamChunk {
     type: 'content' | 'done' | 'error';
     content?: string;
@@ -43,6 +92,68 @@ export interface APIHealthStatus {
     models: EndpointHealthStatus;
     selfHosted: EndpointHealthStatus | null;
 }
+export interface CapabilityTruthStatus {
+    overallOk: boolean;
+    v3Agent: EndpointHealthStatus;
+    hyperLoop: EndpointHealthStatus;
+    repoMemory: EndpointHealthStatus;
+    devtoolsBridge: EndpointHealthStatus;
+}
+export interface VigFlowTemplateSummary {
+    id: string;
+    name: string;
+    description: string;
+    category: string;
+    icon?: string;
+    tags: string[];
+    isBuiltin: boolean;
+    source: string;
+    createdAt?: string;
+}
+export interface VigFlowWorkflowSummary {
+    id: string;
+    name: string;
+    description: string;
+    isActive: boolean;
+    version: string;
+    tags: string[];
+    nodeCount: number;
+    executionCount: number;
+    lastExecutedAt?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface VigFlowWorkflowCreation {
+    id: string;
+    name: string;
+    fromTemplate?: string;
+}
+export interface ResolvedVigFlowWorkflowTarget {
+    id: string;
+    name: string;
+    selector: string;
+    matchedBy: 'id' | 'name' | 'search';
+}
+export interface VigFlowExecutionResult {
+    executionId: string;
+    status: string;
+    result?: unknown;
+    error?: string;
+    nodesExecuted?: number;
+}
+export interface VigFlowExecutionStatus {
+    id: string;
+    workflowId: string;
+    status: string;
+    startedAt?: string;
+    completedAt?: string;
+    nodesExecuted?: number;
+    totalNodes?: number;
+    result?: unknown;
+    error?: string;
+    progress?: Record<string, unknown>;
+    duration?: number;
+}
 export interface VigthoriUser {
     id: string;
     username: string;
@@ -66,6 +177,7 @@ export declare class APIClient {
     private config;
     private logger;
     private ws;
+    private vigFlowTokens;
     constructor(config: Config, logger: Logger);
     private getSelfHostedModelsApiUrl;
     login(email: string, password: string): Promise<boolean>;
@@ -76,8 +188,47 @@ export declare class APIClient {
     private getAccessToken;
     getV3AgentBaseUrls(): string[];
     getV3AgentRunUrl(baseUrl: string): string;
+    getOperatorBaseUrls(): string[];
+    getOperatorStreamUrl(baseUrl: string): string;
+    getMcpBaseUrls(): string[];
+    getVigFlowBaseUrls(): string[];
+    getTemplateServiceBaseUrls(): string[];
+    private isFrontendTask;
+    private normalizeWorkspaceRelativePath;
+    private listFrontendWorkspaceFiles;
+    private chooseFrontendPreviewEntry;
+    private extractLinkedFrontendAssets;
+    private gatherFrontendPreviewArtifacts;
+    private captureFrontendPreviewScreenshot;
+    private evaluateFrontendVisualProof;
+    private persistFrontendPreviewArtifacts;
+    runTemplateServicePreviewGate(message?: string, context?: Record<string, any>): Promise<FrontendPreviewGateResult>;
+    private getMcpContextCreateUrl;
+    private getMcpContextUrl;
+    private getMcpHeaders;
     getV3AgentHeaders(): Promise<Record<string, string>>;
+    private executeV3AgentRunRequest;
+    private getVigFlowAccessToken;
+    private getVigFlowHeaders;
+    private withVigFlow;
+    listVigFlowTemplates(options?: {
+        category?: string;
+        search?: string;
+    }): Promise<VigFlowTemplateSummary[]>;
+    listVigFlowWorkflows(): Promise<VigFlowWorkflowSummary[]>;
+    resolveVigFlowWorkflow(selector: string): Promise<ResolvedVigFlowWorkflowTarget>;
+    useVigFlowTemplate(templateId: string, options?: {
+        name?: string;
+        variables?: Record<string, unknown>;
+    }): Promise<VigFlowWorkflowCreation>;
+    runVigFlowWorkflow(workflowId: string, options?: {
+        data?: Record<string, unknown>;
+        executionOptions?: Record<string, unknown>;
+    }): Promise<VigFlowExecutionResult>;
+    getVigFlowExecutionStatus(executionId: string): Promise<VigFlowExecutionStatus>;
     buildV3AgentContext(context?: Record<string, any>): string;
+    private ensureExecutionContext;
+    bindExecutionContext(context?: Record<string, any>): Promise<Record<string, any>>;
     private resolveAgentTargetPath;
     hasAgentWorkspaceOutput(context?: Record<string, any>): boolean;
     getAgentWorkspaceSnapshot(rootPath: string): {
@@ -95,6 +246,8 @@ export declare class APIClient {
     formatV3AgentResponse(data: any): string;
     collectV3AgentStream(response: Response, context?: Record<string, any>): Promise<any>;
     runV3AgentWorkflow(message: string, context?: Record<string, any>): Promise<V3AgentWorkflowResponse>;
+    private formatOperatorResponse;
+    runOperatorWorkflow(message: string, context?: Record<string, any>): Promise<OperatorWorkflowResponse>;
     /**
      * Chat API - Direct Vigthoria Models API Architecture
      *
@@ -107,11 +260,13 @@ export declare class APIClient {
      * NO localhost fallbacks - CLI is for external users, not server-side!
      */
     chat(messages: ChatMessage[], model: string, useLocal?: boolean): Promise<ChatResponse>;
+    private shouldSkipCloudRoutes;
     private tryChatWithModel;
     private trySelfHostedChatWithModel;
     private getFallbackModelId;
     private isCloudModelId;
     private canUseCloudModel;
+    private resolvePermittedModelId;
     private shouldSimulateCloudFailure;
     private shouldTrySelfHostedFallback;
     private isSelfHostedPreferredModel;
@@ -158,7 +313,11 @@ export declare class APIClient {
     private getCoderHealth;
     private getModelsHealth;
     private getSelfHostedHealth;
+    private getV3AgentHealth;
+    private getHyperLoopHealth;
+    private getRepoMemoryHealth;
+    getDevtoolsBridgeStatus(): Promise<EndpointHealthStatus>;
+    getCapabilityTruthStatus(context?: Record<string, any>): Promise<CapabilityTruthStatus>;
     getHealthStatus(): Promise<APIHealthStatus>;
     healthCheck(): Promise<boolean>;
 }
-//# sourceMappingURL=api.d.ts.map