vigthoria-cli 1.8.12 → 1.8.14

package/dist/commands/cancel.d.ts

@@ -0,0 +1,18 @@
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+interface CancelOptions {
+    all?: boolean;
+    list?: boolean;
+    json?: boolean;
+}
+export declare class CancelCommand {
+    private config;
+    private logger;
+    constructor(config: Config, logger: Logger);
+    private getHeaders;
+    private getBaseUrl;
+    private listActive;
+    private cancelOne;
+    run(contextId: string | undefined, options: CancelOptions): Promise<void>;
+}
+export {};

package/dist/commands/cancel.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancelCommand = void 0;
+const api_js_1 = require("../utils/api.js");
+/**
+ * cancel.ts — Cancel an in-flight V3 agent run, or cancel all active runs.
+ *
+ * Usage:
+ *   vig cancel <context_id>       Cancel a single run
+ *   vig cancel --all              Cancel every currently-active run
+ *   vig cancel --list             Just list active runs (no cancellation)
+ */
+const chalk_1 = __importDefault(require("chalk"));
+const logger_js_1 = require("../utils/logger.js");
+class CancelCommand {
+    config;
+    logger;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    getHeaders() {
+        const headers = { 'Content-Type': 'application/json' };
+        const token = process.env.VIGTHORIA_TOKEN ||
+            process.env.VIGTHORIA_AUTH_TOKEN ||
+            this.config.get('authToken');
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
+            headers['Cookie'] = `vigthoria-auth-token=${token}`;
+        }
+        const serviceKey = process.env.VIGTHORIA_V3_SERVICE_KEY;
+        if (serviceKey)
+            headers['X-Service-Key'] = serviceKey;
+        return headers;
+    }
+    getBaseUrl() {
+        const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
+        const allowLocal = (0, api_js_1.isServerRuntime)() && process.env.VIGTHORIA_ALLOW_LOCAL_V3_AGENT === '1';
+        return (process.env.VIGTHORIA_V3_AGENT_URL ||
+            process.env.V3_AGENT_URL ||
+            (allowLocal ? 'http://127.0.0.1:8030' : null) ||
+            configuredApiUrl);
+    }
+    async listActive(baseUrl) {
+        const resp = await fetch(`${baseUrl}/api/runs/active`, { headers: this.getHeaders() });
+        if (!resp.ok) {
+            if (resp.status === 404 || resp.status === 502 || resp.status === 503) {
+                this.logger.error(`V3 cancel API is not available on ${baseUrl}. Backend may not expose /api/runs/active. ` +
+                    `(Requires V3 agent server.py with the cancel endpoint patched in.)`);
+            }
+            else if (resp.status === 401 || resp.status === 403) {
+                this.logger.error(`Authentication failed (${resp.status}). Run \`vig login\` first.`);
+            }
+            else {
+                this.logger.error(`Failed to list active runs: ${resp.status} ${resp.statusText}`);
+            }
+            return null;
+        }
+        return (await resp.json());
+    }
+    async cancelOne(baseUrl, contextId) {
+        const resp = await fetch(`${baseUrl}/api/runs/${encodeURIComponent(contextId)}/cancel`, { method: 'POST', headers: this.getHeaders() });
+        if (!resp.ok) {
+            if (resp.status === 404) {
+                this.logger.warn(`No active run for context_id=${contextId}`);
+            }
+            else if (resp.status === 401 || resp.status === 403) {
+                this.logger.error(`Authentication failed (${resp.status}). Run \`vig login\` first.`);
+            }
+            else {
+                this.logger.error(`Cancel failed for ${contextId}: ${resp.status} ${resp.statusText}`);
+            }
+            return null;
+        }
+        return (await resp.json());
+    }
+    async run(contextId, options) {
+        const baseUrl = this.getBaseUrl();
+        if (options.list) {
+            const spinner = (0, logger_js_1.createSpinner)('Loading active runs...').start();
+            const active = await this.listActive(baseUrl);
+            spinner.stop();
+            if (!active)
+                return;
+            if (options.json) {
+                console.log(JSON.stringify(active, null, 2));
+                return;
+            }
+            if (active.active_count === 0) {
+                this.logger.info(chalk_1.default.dim('No active runs.'));
+                return;
+            }
+            console.log(chalk_1.default.bold(`\n${logger_js_1.CH.success} Active Runs (${active.active_count}/${active.max_concurrent_runs})\n`));
+            for (const cid of active.active_context_ids) {
+                console.log(`  ${chalk_1.default.cyan(cid)}`);
+            }
+            console.log();
+            return;
+        }
+        if (options.all) {
+            const spinner = (0, logger_js_1.createSpinner)('Loading active runs...').start();
+            const active = await this.listActive(baseUrl);
+            spinner.stop();
+            if (!active)
+                return;
+            if (active.active_count === 0) {
+                this.logger.info(chalk_1.default.dim('No active runs to cancel.'));
+                return;
+            }
+            const results = [];
+            for (const cid of active.active_context_ids) {
+                const sp = (0, logger_js_1.createSpinner)(`Cancelling ${cid}...`).start();
+                const r = await this.cancelOne(baseUrl, cid);
+                sp.stop();
+                if (r) {
+                    results.push(r);
+                    this.logger.success(`Cancelled ${chalk_1.default.cyan(cid)} (asyncio_cancelled=${r.asyncio_cancelled})`);
+                }
+            }
+            if (options.json)
+                console.log(JSON.stringify({ cancelled: results }, null, 2));
+            return;
+        }
+        if (!contextId) {
+            this.logger.error('Usage: vig cancel <context_id> | --all | --list');
+            return;
+        }
+        const spinner = (0, logger_js_1.createSpinner)(`Cancelling ${contextId}...`).start();
+        const r = await this.cancelOne(baseUrl, contextId);
+        spinner.stop();
+        if (!r)
+            return;
+        if (options.json) {
+            console.log(JSON.stringify(r, null, 2));
+            return;
+        }
+        this.logger.success(`Cancelled ${chalk_1.default.cyan(contextId)} ` +
+            `(asyncio_cancelled=${r.asyncio_cancelled}, active_runs_after=${r.active_runs_after})`);
+    }
+}
+exports.CancelCommand = CancelCommand;

package/dist/index.js

@@ -71,6 +71,7 @@ const legion_js_1 = require("./commands/legion.js");
 const history_js_1 = require("./commands/history.js");
 const replay_js_1 = require("./commands/replay.js");
 const fork_js_1 = require("./commands/fork.js");
+const cancel_js_1 = require("./commands/cancel.js");
 const config_js_2 = require("./utils/config.js");
 const logger_js_1 = require("./utils/logger.js");
 const chalk_1 = __importDefault(require("chalk"));
@@ -163,7 +164,7 @@ async function main() {
     const directPromptRequested = process.argv.includes('--prompt') || process.argv.includes('-P');
     if (invokedBinaryName === 'vigthoria-chat') {
         const knownCommands = new Set([
-            'chat', 'chat-resume', 'agent', 'edit', 'generate', 'explain', 'fix', 'review',
+            'chat', 'chat-resume', 'agent', 'edit', 'generate', 'explain', 'fix', 'review', 'cancel',
             'hub', 'repo', 'deploy', 'operator', 'workflow', 'flow', 'login', 'logout', 'status', 'config', 'update',
             '--help', '-h', '--version', '-V', 'help', 'version',
         ]);
@@ -770,6 +771,16 @@ Examples:
         const fork = new fork_js_1.ForkCommand(config, logger);
         await fork.run(runId, message || '', { eventIndex: parseInt(options.eventIndex, 10) || 0, project: options.project, json: options.json });
     });
+    program
+        .command('cancel [contextId]')
+        .description('Cancel an in-flight V3 agent run (by context_id), or use --all to cancel every active run')
+        .option('-a, --all', 'Cancel all currently-active runs', false)
+        .option('-l, --list', 'List active runs without cancelling', false)
+        .option('--json', 'Machine-readable JSON output', false)
+        .action(async (contextId, options) => {
+        const cancel = new cancel_js_1.CancelCommand(config, logger);
+        await cancel.run(contextId, { all: options.all, list: options.list, json: options.json });
+    });
     // ==================== AUTH COMMANDS ====================
     // Auth commands
     program

package/dist/utils/tools.d.ts

@@ -193,6 +193,7 @@ export declare class AgenticTools {
      * Uses Node.js native fetch (available in Node 18+)
      */
     private fetchUrl;
+    private browserTool;
     /**
      * Execute command via SSH on remote server
      * Useful for running Unix commands from Windows

package/dist/utils/tools.js

@@ -399,6 +399,19 @@ class AgenticTools {
                 riskLevel: 'low',
                 category: 'read',
             },
+            {
+                name: 'browser',
+                description: 'Drive a real headless Chromium via the Vigthoria DevTools Bridge. Use to capture a page (screenshot+HTML+metrics), collect console/page errors, or run a quick smoke test on a URL. Cross-platform.',
+                parameters: [
+                    { name: 'mode', description: "One of: 'capture' (screenshot + html + metrics), 'errors' (console + page errors), 'test' (quick smoke test)", required: true },
+                    { name: 'url', description: 'Target URL (must start with http:// or https://)', required: true },
+                    { name: 'include_screenshot', description: "For mode=capture: 'true' to include base64 screenshot (default true), 'false' to skip", required: false },
+                ],
+                requiresPermission: true,
+                dangerous: false,
+                riskLevel: 'low',
+                category: 'read',
+            },
             {
                 name: 'ssh_exec',
                 description: 'Execute a command on a remote server via SSH (useful for Unix commands from Windows)',
@@ -602,6 +615,8 @@ class AgenticTools {
                 return this.repo(call.args);
             case 'fetch_url':
                 return this.fetchUrl(call.args);
+            case 'browser':
+                return this.browserTool(call.args);
             case 'ssh_exec':
                 return this.sshExec(call.args);
             case 'task':
@@ -1857,6 +1872,74 @@ class AgenticTools {
             return this.createErrorResult(ToolErrorType.NETWORK_ERROR, error.message, 'Check your internet connection and ensure the URL is correct.');
         }
     }
+    async browserTool(args) {
+        const mode = (args.mode || '').toLowerCase();
+        const url = args.url;
+        if (!['capture', 'errors', 'test'].includes(mode)) {
+            return this.createErrorResult(ToolErrorType.INVALID_ARGS, `Invalid mode: ${args.mode}`, "mode must be one of: 'capture', 'errors', 'test'");
+        }
+        if (!url || (!url.startsWith('http://') && !url.startsWith('https://'))) {
+            return this.createErrorResult(ToolErrorType.INVALID_ARGS, 'URL must start with http:// or https://', 'Provide a valid URL, e.g., https://example.com');
+        }
+        const host = process.env.VIGTHORIA_DEVTOOLS_BRIDGE_HOST || '127.0.0.1';
+        const port = process.env.VIGTHORIA_DEVTOOLS_BRIDGE_PORT || '4016';
+        const base = `http://${host}:${port}`;
+        const toolName = mode === 'capture' ? 'capture_state' :
+            mode === 'errors' ? 'get_page_errors' :
+                'run_test';
+        const params = { url };
+        if (mode === 'capture' && (args.include_screenshot || '').toLowerCase() === 'false') {
+            params.includeScreenshot = false;
+        }
+        if (mode === 'test') {
+            params.testType = 'quick';
+        }
+        const controller = new AbortController();
+        const timeoutMs = mode === 'test' ? 60000 : 45000;
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const res = await fetch(`${base}/api/mcp/tools`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'User-Agent': 'Vigthoria-CLI-Browser/1.0' },
+                body: JSON.stringify({ tool: toolName, params }),
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            if (!res.ok) {
+                return this.createErrorResult(ToolErrorType.NETWORK_ERROR, `DevTools Bridge HTTP ${res.status}`, 'Ensure the bridge is running (vigthoria bridge status). On a developer workstation it must be installed and started locally.');
+            }
+            const data = await res.json();
+            if (!data.success) {
+                return this.createErrorResult(ToolErrorType.NETWORK_ERROR, data.error || 'DevTools Bridge returned unsuccessful response', 'Check the bridge logs.');
+            }
+            let payload;
+            if (mode === 'capture' && data.result && typeof data.result === 'object') {
+                const r = data.result;
+                const trimmed = {
+                    url: r.url,
+                    timestamp: r.timestamp,
+                    metrics: r.metrics,
+                    performance: r.performance,
+                    html_excerpt: typeof r.html === 'string' ? r.html.slice(0, 4000) : undefined,
+                    screenshot_data_url_length: typeof r.screenshot === 'string' ? r.screenshot.length : 0,
+                };
+                payload = JSON.stringify(trimmed, null, 2);
+            }
+            else {
+                payload = JSON.stringify(data.result, null, 2).slice(0, 8000);
+            }
+            return {
+                success: true,
+                output: payload,
+                metadata: { tool: 'browser', mode, url },
+            };
+        }
+        catch (e) {
+            clearTimeout(timeout);
+            const msg = e instanceof Error ? e.message : String(e);
+            return this.createErrorResult(ToolErrorType.NETWORK_ERROR, `Browser tool failed: ${msg}`, "Verify the DevTools Bridge is reachable on host:port (defaults 127.0.0.1:4016).");
+        }
+    }
     /**
      * Execute command via SSH on remote server
      * Useful for running Unix commands from Windows

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.8.12",
+  "version": "1.8.14",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "main": "dist/index.js",
   "files": [