vigthoria-cli 1.10.37 → 1.10.47

package/dist/commands/agent-session-menu.d.ts

@@ -0,0 +1,19 @@
+export interface AgentSessionConfig {
+    workspacePath: string;
+    debugMode: boolean;
+    autoApprove: boolean;
+    autoSave: boolean;
+}
+export interface AgentSessionMenuDefaults {
+    workspacePath?: string;
+    debugMode?: boolean;
+    autoApprove?: boolean;
+    autoSave?: boolean;
+}
+export interface AgentSessionMenuOptions {
+    prompt?: string;
+    json?: boolean;
+    projectProvided?: boolean;
+}
+export declare function shouldShowAgentSessionMenu(options?: AgentSessionMenuOptions): boolean;
+export declare function runAgentSessionMenu(defaults?: AgentSessionMenuDefaults): Promise<AgentSessionConfig>;

package/dist/commands/agent-session-menu.js

@@ -0,0 +1,155 @@
+/**
+ * Interactive agent/operator session setup menu (Node inquirer — CLI equivalent of InquirerPy).
+ */
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+function validateExistingDirectory(input) {
+    const trimmed = String(input || '').trim().replace(/^['"]|['"]$/g, '');
+    if (!trimmed) {
+        return 'Path is required.';
+    }
+    const resolved = path.resolve(trimmed);
+    try {
+        if (!fs.existsSync(resolved)) {
+            return `Directory does not exist: ${resolved}`;
+        }
+        if (!fs.statSync(resolved).isDirectory()) {
+            return `Not a directory: ${resolved}`;
+        }
+    }
+    catch (error) {
+        return `Cannot access path: ${error?.message || error}`;
+    }
+    return true;
+}
+
+export function shouldShowAgentSessionMenu(options = {}) {
+    if (options.prompt) {
+        return false;
+    }
+    if (options.json) {
+        return false;
+    }
+    if (options.projectProvided) {
+        return false;
+    }
+    if (/^(1|true|yes)$/i.test(String(process.env.VIGTHORIA_NO_SESSION_MENU || ''))) {
+        return false;
+    }
+    return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
+
+export async function runAgentSessionMenu(defaults = {}) {
+    const session = {
+        workspacePath: path.resolve(String(defaults.workspacePath || process.cwd())),
+        debugMode: defaults.debugMode === true,
+        autoApprove: defaults.autoApprove === true,
+        autoSave: defaults.autoSave !== false,
+    };
+    const recentHint = String(defaults.configuredRoot || '').trim();
+    let done = false;
+    let menuPass = 0;
+    while (!done) {
+        if (menuPass === 0) {
+            console.log();
+            console.log(chalk.cyan('═══ Agent Session Setup ═══'));
+        }
+        else {
+            console.log();
+            console.log(chalk.cyan('── Session settings ──'));
+        }
+        menuPass += 1;
+        console.log(chalk.gray(`Workspace: ${session.workspacePath}`));
+        if (recentHint && recentHint !== session.workspacePath) {
+            console.log(chalk.gray(`Configured default: ${recentHint}`));
+        }
+        console.log(chalk.gray(`Debug: ${session.debugMode ? 'on' : 'off'} | Auto-approve: ${session.autoApprove ? 'on' : 'off'} | Auto-save: ${session.autoSave ? 'on' : 'off'}`));
+        console.log();
+        const { action } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'Configure your session',
+                choices: [
+                    { name: 'Set workspace path (existing directory)', value: 'set-workspace' },
+                    { name: 'Create new directory and set as workspace', value: 'create-workspace' },
+                    { name: 'Session settings (debug, auto-save, auto-approve)', value: 'settings' },
+                    { name: 'Start session with current settings', value: 'start' },
+                ],
+            },
+        ]);
+        if (action === 'set-workspace') {
+            const { workspacePath } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'workspacePath',
+                    message: 'Workspace directory path:',
+                    default: session.workspacePath,
+                    validate: validateExistingDirectory,
+                },
+            ]);
+            session.workspacePath = path.resolve(workspacePath);
+        }
+        else if (action === 'create-workspace') {
+            const { basePath, folderName } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'basePath',
+                    message: 'Base directory:',
+                    default: os.homedir(),
+                    validate: validateExistingDirectory,
+                },
+                {
+                    type: 'input',
+                    name: 'folderName',
+                    message: 'New folder name:',
+                    validate: (value) => {
+                        const trimmed = String(value || '').trim();
+                        if (!trimmed) {
+                            return 'Folder name is required.';
+                        }
+                        if (/[<>:"|?*\x00]/.test(trimmed)) {
+                            return 'Folder name contains invalid characters.';
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            const target = path.join(path.resolve(basePath), String(folderName).trim());
+            fs.mkdirSync(target, { recursive: true });
+            session.workspacePath = target;
+            console.log(chalk.green(`Created workspace: ${target}`));
+        }
+        else if (action === 'settings') {
+            const settings = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'debugMode',
+                    message: 'Enable debug mode (verbose logging)?',
+                    default: session.debugMode,
+                },
+                {
+                    type: 'confirm',
+                    name: 'autoSave',
+                    message: 'Auto-save session on exit?',
+                    default: session.autoSave,
+                },
+                {
+                    type: 'confirm',
+                    name: 'autoApprove',
+                    message: 'Auto-approve tool actions (dangerous)?',
+                    default: session.autoApprove,
+                },
+            ]);
+            Object.assign(session, settings);
+        }
+        else {
+            done = true;
+        }
+    }
+    return session;
+}

package/dist/commands/auth.js

@@ -1,12 +1,29 @@
-import chalk from 'chalk';
-import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
-import { homedir } from 'os';
-import path from 'path';
-import readline from 'readline';
-import { Config } from '../utils/config.js';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAuthConfig = loadAuthConfig;
+exports.saveAuthConfig = saveAuthConfig;
+exports.clearAuthConfig = clearAuthConfig;
+exports.getAuthToken = getAuthToken;
+exports.login = login;
+exports.logout = logout;
+exports.whoami = whoami;
+exports.doctor = doctor;
+exports.handleLogin = handleLogin;
+exports.handleLogout = handleLogout;
+exports.statusAction = statusAction;
+exports.registerAuthCommands = registerAuthCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = __importDefault(require("path"));
+const readline_1 = __importDefault(require("readline"));
+const config_js_1 = require("../utils/config.js");
 const DEFAULT_API_URL = 'https://coder.vigthoria.io';
-const CONFIG_DIR = path.join(homedir(), '.vigthoria');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const CONFIG_DIR = path_1.default.join((0, os_1.homedir)(), '.vigthoria');
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
 const KNOWN_AUTH_BASE_URLS = ['https://coder.vigthoria.io'];
 class HttpError extends Error {
     status;
@@ -39,11 +56,11 @@ function getAuthBaseCandidates(seedBaseUrl) {
     return uniqueStrings([seed, ...(peer ? [peer] : []), ...KNOWN_AUTH_BASE_URLS]).map(trimTrailingSlash);
 }
 function ensureConfigDir() {
-    if (!existsSync(CONFIG_DIR)) {
-        mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    if (!(0, fs_1.existsSync)(CONFIG_DIR)) {
+        (0, fs_1.mkdirSync)(CONFIG_DIR, { recursive: true, mode: 0o700 });
     }
     try {
-        chmodSync(CONFIG_DIR, 0o700);
+        (0, fs_1.chmodSync)(CONFIG_DIR, 0o700);
     }
     catch {
         // Best-effort on non-POSIX filesystems.
@@ -51,7 +68,7 @@ function ensureConfigDir() {
 }
 function syncSharedConfig(config) {
     try {
-        const shared = new Config();
+        const shared = new config_js_1.Config();
         shared.set('apiUrl', trimTrailingSlash(config.apiUrl || getApiUrl()));
         if (config.token) {
             shared.set('authToken', config.token);
@@ -72,7 +89,7 @@ function syncSharedConfig(config) {
 }
 function clearSharedConfigAuth() {
     try {
-        const shared = new Config();
+        const shared = new config_js_1.Config();
         shared.set('authToken', null);
         shared.set('refreshToken', null);
         shared.set('userId', null);
@@ -120,12 +137,12 @@ function extractAuthUser(payload, fallbackEmail) {
     }
     return fallbackEmail ? { email: fallbackEmail } : undefined;
 }
-export function loadAuthConfig() {
-    if (!existsSync(CONFIG_FILE)) {
+function loadAuthConfig() {
+    if (!(0, fs_1.existsSync)(CONFIG_FILE)) {
         return { apiUrl: getApiUrl() };
     }
     try {
-        const parsed = JSON.parse(readFileSync(CONFIG_FILE, 'utf8'));
+        const parsed = JSON.parse((0, fs_1.readFileSync)(CONFIG_FILE, 'utf8'));
         return {
             apiUrl: trimTrailingSlash(parsed.apiUrl || getApiUrl()),
             token: parsed.token || parsed.authToken,
@@ -134,28 +151,28 @@ export function loadAuthConfig() {
         };
     }
     catch (error) {
-        console.warn(chalk.yellow(`Warning: could not read auth config: ${humanMessage(error)}`));
+        console.warn(chalk_1.default.yellow(`Warning: could not read auth config: ${humanMessage(error)}`));
         return { apiUrl: getApiUrl() };
     }
 }
-export function saveAuthConfig(config) {
+function saveAuthConfig(config) {
     ensureConfigDir();
-    writeFileSync(CONFIG_FILE, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+    (0, fs_1.writeFileSync)(CONFIG_FILE, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
     try {
-        chmodSync(CONFIG_FILE, 0o600);
+        (0, fs_1.chmodSync)(CONFIG_FILE, 0o600);
     }
     catch {
         // Best-effort on non-POSIX filesystems.
     }
     syncSharedConfig(config);
 }
-export function clearAuthConfig() {
-    if (existsSync(CONFIG_FILE)) {
-        rmSync(CONFIG_FILE, { force: true });
+function clearAuthConfig() {
+    if ((0, fs_1.existsSync)(CONFIG_FILE)) {
+        (0, fs_1.rmSync)(CONFIG_FILE, { force: true });
     }
     clearSharedConfigAuth();
 }
-export function getAuthToken() {
+function getAuthToken() {
     return process.env.VIGTHORIA_TOKEN || loadAuthConfig().token;
 }
 async function requestJson(url, init) {
@@ -226,7 +243,7 @@ async function fetchV3ServiceKey(apiBase, token) {
     return undefined;
 }
 async function ask(question, hidden = false) {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
     if (!hidden) {
         try {
             return await new Promise((resolve) => rl.question(question, resolve));
@@ -265,7 +282,7 @@ function markSuccessExit() {
 function markErrorExit() {
     process.exitCode = 1;
 }
-export async function login(email, password) {
+async function login(email, password) {
     try {
         const resolvedEmail = (email || '').trim();
         const resolvedPassword = password || '';
@@ -322,7 +339,7 @@ export async function login(email, password) {
         throw new Error(message);
     }
 }
-export async function logout() {
+async function logout() {
     const config = loadAuthConfig();
     if (config.token) {
         const bases = getAuthBaseCandidates(config.apiUrl || getApiUrl());
@@ -347,13 +364,13 @@ export async function logout() {
             }
         }
         if (!remoteLogoutDone) {
-            console.warn(chalk.yellow('Remote logout endpoint not reachable; local credentials were still cleared.'));
+            console.warn(chalk_1.default.yellow('Remote logout endpoint not reachable; local credentials were still cleared.'));
         }
     }
     clearAuthConfig();
     process.exitCode = 0;
 }
-export async function whoami() {
+async function whoami() {
     const config = loadAuthConfig();
     if (!config.token) {
         return undefined;
@@ -401,7 +418,7 @@ export async function whoami() {
     }
     throw new Error(`Unable to verify account on known auth endpoints. Tried ${attempted.join(', ')}`);
 }
-export async function doctor() {
+async function doctor() {
     const config = loadAuthConfig();
     const report = {
         nodeVersion: process.version,
@@ -414,7 +431,7 @@ export async function doctor() {
     process.exitCode = 0;
     return report;
 }
-export async function handleLogin(options = {}) {
+async function handleLogin(options = {}) {
     try {
         if (options.token) {
             const config = {
@@ -427,14 +444,14 @@ export async function handleLogin(options = {}) {
                 config.v3ServiceKey = v3ServiceKey;
             }
             saveAuthConfig(config);
-            console.log(chalk.green('Logged in successfully with API token.'));
+            console.log(chalk_1.default.green('Logged in successfully with API token.'));
             process.exitCode = 0;
             return config;
         }
         let email = options.email?.trim();
         let password = options.password;
         if (options.device) {
-            console.log(chalk.yellow('Device-code login is not enabled by this Vigthoria service. Falling back to email and password authentication.'));
+            console.log(chalk_1.default.yellow('Device-code login is not enabled by this Vigthoria service. Falling back to email and password authentication.'));
         }
         if (!email) {
             email = (await ask('Email: ')).trim();
@@ -446,7 +463,7 @@ export async function handleLogin(options = {}) {
             throw new Error('Email and password are required. Use --email and --password, or run vigthoria login interactively.');
         }
         const config = await login(email, password);
-        console.log(chalk.green('Logged in successfully.'));
+        console.log(chalk_1.default.green('Logged in successfully.'));
         if (config.user?.email) {
             console.log(`Account: ${config.user.email}`);
         }
@@ -472,7 +489,7 @@ export async function handleLogin(options = {}) {
         }
         catch { /* non-fatal — login already succeeded */ }
         try {
-            const sharedConfig = new Config();
+            const sharedConfig = new config_js_1.Config();
             await sharedConfig.refreshHubModelPreferences();
             const hubPrefs = sharedConfig.get('hubModelPrefs');
             if (hubPrefs?.balance !== undefined) {
@@ -485,32 +502,32 @@ export async function handleLogin(options = {}) {
         return config;
     }
     catch (error) {
-        console.error(chalk.red(`Login failed: ${humanMessage(error)}`));
+        console.error(chalk_1.default.red(`Login failed: ${humanMessage(error)}`));
         process.exitCode = 1;
         return undefined;
     }
 }
-export async function handleLogout(_options) {
+async function handleLogout(_options) {
     try {
         await logout();
-        console.log(chalk.green('Logged out successfully.'));
+        console.log(chalk_1.default.green('Logged out successfully.'));
         process.exitCode = 0;
     }
     catch (error) {
-        console.error(chalk.red(`Logout failed: ${humanMessage(error)}`));
+        console.error(chalk_1.default.red(`Logout failed: ${humanMessage(error)}`));
         process.exitCode = 1;
     }
 }
-export async function statusAction() {
+async function statusAction() {
     try {
         const legacyConfig = loadAuthConfig();
-        const sharedConfig = new Config();
+        const sharedConfig = new config_js_1.Config();
         const sharedApiUrl = String(sharedConfig.get('apiUrl') || '').trim();
         const sharedToken = String(sharedConfig.get('authToken') || '').trim();
         const effectiveApiUrl = trimTrailingSlash(sharedApiUrl || legacyConfig.apiUrl || getApiUrl());
         const effectiveToken = sharedToken || legacyConfig.token || '';
         if (!effectiveToken) {
-            console.log(chalk.yellow('Not logged in.'));
+            console.log(chalk_1.default.yellow('Not logged in.'));
             process.exitCode = 0;
             return;
         }
@@ -529,8 +546,8 @@ export async function statusAction() {
             // Network failures should not force logout status.
         }
         if (!authLooksValid) {
-            console.log(chalk.yellow('Not logged in. Session expired or invalid.'));
-            console.log(chalk.gray('Run: vigthoria login'));
+            console.log(chalk_1.default.yellow('Not logged in. Session expired or invalid.'));
+            console.log(chalk_1.default.gray('Run: vigthoria login'));
             process.exitCode = 1;
             return;
         }
@@ -562,8 +579,8 @@ export async function statusAction() {
             // Status should still render even if health probes fail.
         }
         const plan = String(sharedConfig.get('subscription')?.plan || '').trim();
-        console.log(chalk.white('Account Status'));
-        console.log(chalk.green('Logged in.'));
+        console.log(chalk_1.default.white('Account Status'));
+        console.log(chalk_1.default.green('Logged in.'));
         if (user?.email) {
             console.log(`Account: ${user.email}`);
         }
@@ -577,11 +594,11 @@ export async function statusAction() {
         process.exitCode = 0;
     }
     catch (error) {
-        console.error(chalk.red(`Unable to read status: ${humanMessage(error)}`));
+        console.error(chalk_1.default.red(`Unable to read status: ${humanMessage(error)}`));
         process.exitCode = 1;
     }
 }
-export function registerAuthCommands(program) {
+function registerAuthCommands(program) {
     const auth = program.command('auth').description('Manage Vigthoria CLI authentication');
     auth
         .command('login')
@@ -606,16 +623,16 @@ export function registerAuthCommands(program) {
         try {
             const user = await whoami();
             if (!user) {
-                console.log(chalk.yellow('Not logged in.'));
+                console.log(chalk_1.default.yellow('Not logged in.'));
                 process.exitCode = 0;
                 return;
             }
-            console.log(chalk.green('Logged in.'));
+            console.log(chalk_1.default.green('Logged in.'));
             console.log(user.email || user.name || user.id || 'Authenticated user');
             process.exitCode = 0;
         }
         catch (error) {
-            console.error(chalk.red(`Unable to fetch account: ${humanMessage(error)}`));
+            console.error(chalk_1.default.red(`Unable to fetch account: ${humanMessage(error)}`));
             process.exitCode = 1;
         }
     });

package/dist/commands/bridge.js

@@ -1,27 +1,34 @@
-import chalk from 'chalk';
-import { createSpinner } from '../utils/logger.js';
-import { APIClient } from '../utils/api.js';
-export class BridgeCommand {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeCommand = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const logger_js_1 = require("../utils/logger.js");
+const api_js_1 = require("../utils/api.js");
+class BridgeCommand {
     api;
     constructor(config, logger) {
-        this.api = new APIClient(config, logger);
+        this.api = new api_js_1.APIClient(config, logger);
     }
     async status() {
-        const spinner = createSpinner('Checking DevTools Bridge...').start();
+        const spinner = (0, logger_js_1.createSpinner)('Checking DevTools Bridge...').start();
         const bridge = await this.api.getDevtoolsBridgeStatus();
         spinner.stop();
         console.log();
-        console.log(chalk.white('DevTools Bridge:'));
-        console.log(chalk.gray('  Status: ') + (bridge.ok ? chalk.green('Reachable') : chalk.yellow('Not running')));
+        console.log(chalk_1.default.white('DevTools Bridge:'));
+        console.log(chalk_1.default.gray('  Status: ') + (bridge.ok ? chalk_1.default.green('Reachable') : chalk_1.default.yellow('Not running')));
         if (!bridge.ok) {
             const detail = String(bridge.error || 'Connection refused').trim() || 'Connection refused';
-            console.log(chalk.gray('  Error: ') + chalk.yellow(detail));
+            console.log(chalk_1.default.gray('  Error: ') + chalk_1.default.yellow(detail));
         }
-        console.log(chalk.gray('  Browser tasks: ') + (bridge.ok
-            ? chalk.green('Local browser observability is available for debugging flows.')
-            : chalk.gray('Start the DevTools Bridge to enable local browser observability.')));
+        console.log(chalk_1.default.gray('  Browser tasks: ') + (bridge.ok
+            ? chalk_1.default.green('Local browser observability is available for debugging flows.')
+            : chalk_1.default.gray('Start the DevTools Bridge to enable local browser observability.')));
         console.log();
         this.api.destroy();
         process.exitCode = 0;
     }
 }
+exports.BridgeCommand = BridgeCommand;

package/dist/commands/cancel.js

@@ -1,4 +1,10 @@
-import { isServerRuntime } from '../utils/api.js';
+"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.
  *
@@ -7,9 +13,9 @@ import { isServerRuntime } from '../utils/api.js';
  *   vig cancel --all              Cancel every currently-active run
  *   vig cancel --list             Just list active runs (no cancellation)
  */
-import chalk from 'chalk';
-import { createSpinner, CH } from '../utils/logger.js';
-export class CancelCommand {
+const chalk_1 = __importDefault(require("chalk"));
+const logger_js_1 = require("../utils/logger.js");
+class CancelCommand {
     config;
     logger;
     constructor(config, logger) {
@@ -32,7 +38,7 @@ export class CancelCommand {
     }
     getBaseUrl() {
         const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
-        const allowLocal = !isServerRuntime() || process.env.VIGTHORIA_ALLOW_LOCAL_V3_AGENT === '1';
+        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) ||
@@ -74,7 +80,7 @@ export class CancelCommand {
     async run(contextId, options) {
         const baseUrl = this.getBaseUrl();
         if (options.list) {
-            const spinner = createSpinner('Loading active runs...').start();
+            const spinner = (0, logger_js_1.createSpinner)('Loading active runs...').start();
             const active = await this.listActive(baseUrl);
             spinner.stop();
             if (!active)
@@ -84,34 +90,34 @@ export class CancelCommand {
                 return;
             }
             if (active.active_count === 0) {
-                this.logger.info(chalk.dim('No active runs.'));
+                this.logger.info(chalk_1.default.dim('No active runs.'));
                 return;
             }
-            console.log(chalk.bold(`\n${CH.success} Active Runs (${active.active_count}/${active.max_concurrent_runs})\n`));
+            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.cyan(cid)}`);
+                console.log(`  ${chalk_1.default.cyan(cid)}`);
             }
             console.log();
             return;
         }
         if (options.all) {
-            const spinner = createSpinner('Loading active runs...').start();
+            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.dim('No active runs to cancel.'));
+                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 = createSpinner(`Cancelling ${cid}...`).start();
+                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.cyan(cid)} (asyncio_cancelled=${r.asyncio_cancelled})`);
+                    this.logger.success(`Cancelled ${chalk_1.default.cyan(cid)} (asyncio_cancelled=${r.asyncio_cancelled})`);
                 }
             }
             if (options.json)
@@ -122,7 +128,7 @@ export class CancelCommand {
             this.logger.error('Usage: vig cancel <context_id> | --all | --list');
             return;
         }
-        const spinner = createSpinner(`Cancelling ${contextId}...`).start();
+        const spinner = (0, logger_js_1.createSpinner)(`Cancelling ${contextId}...`).start();
         const r = await this.cancelOne(baseUrl, contextId);
         spinner.stop();
         if (!r)
@@ -131,7 +137,8 @@ export class CancelCommand {
             console.log(JSON.stringify(r, null, 2));
             return;
         }
-        this.logger.success(`Cancelled ${chalk.cyan(contextId)} ` +
+        this.logger.success(`Cancelled ${chalk_1.default.cyan(contextId)} ` +
             `(asyncio_cancelled=${r.asyncio_cancelled}, active_runs_after=${r.active_runs_after})`);
     }
 }
+exports.CancelCommand = CancelCommand;