vigthoria-cli 1.13.18 → 1.13.22

package/dist/utils/codebase-indexer.d.ts

@@ -42,6 +42,7 @@ export declare class CodebaseIndexer {
     static metaPath(workspaceRoot: string): string;
     static loadMeta(workspaceRoot: string): IndexMeta | null;
     private saveMeta;
+    private static metaStore;
     hasLocalIndex(): boolean;
     countCandidateFiles(): number;
     countIndexableFiles(): number;

package/dist/utils/codebase-indexer.js

@@ -4,6 +4,8 @@
 import * as crypto from 'crypto';
 import * as fs from 'fs';
 import * as path from 'path';
+import { containsHighConfidenceSecret, isSensitivePath } from './secret-policy.js';
+import { DurableJsonStore } from './durable-json.js';
 export class CodebaseIndexer {
     workspaceRoot;
     index = new Map();
@@ -32,7 +34,7 @@ export class CodebaseIndexer {
         '.html', '.css', '.scss', '.less', '.sass',
         '.json', '.yaml', '.yml', '.toml', '.xml',
         '.md', '.txt', '.rst', '.sh', '.bash', '.zsh',
-        '.sql', '.graphql', '.prisma', '.env',
+        '.sql', '.graphql', '.prisma',
         '.dockerfile', '.tf', '.hcl',
     ]);
     constructor(workspaceRoot) {
@@ -51,9 +53,7 @@ export class CodebaseIndexer {
     static loadMeta(workspaceRoot) {
         try {
             const metaPath = CodebaseIndexer.metaPath(workspaceRoot);
-            if (fs.existsSync(metaPath)) {
-                return JSON.parse(fs.readFileSync(metaPath, 'utf8'));
-            }
+            return CodebaseIndexer.metaStore(metaPath).read();
         }
         catch {
             // fresh workspace
@@ -62,8 +62,24 @@ export class CodebaseIndexer {
     }
     saveMeta(meta) {
         const dir = path.join(this.workspaceRoot, '.vigthoria', 'index');
-        fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(CodebaseIndexer.metaPath(this.workspaceRoot), `${JSON.stringify(meta, null, 2)}\n`);
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const metaPath = CodebaseIndexer.metaPath(this.workspaceRoot);
+        CodebaseIndexer.metaStore(metaPath).write(meta);
+    }
+    static metaStore(metaPath) {
+        const isMeta = (value) => value === null || Boolean(value && typeof value === 'object'
+            && typeof value.indexedFileCount === 'number'
+            && typeof value.totalChunks === 'number'
+            && typeof value.indexHash === 'string'
+            && Array.isArray(value.topFiles)
+            && typeof value.indexedAt === 'string');
+        return new DurableJsonStore({
+            filePath: metaPath,
+            schemaVersion: 1,
+            defaultValue: () => null,
+            validate: isMeta,
+            migrate: (value) => isMeta(value) ? value : null,
+        });
     }
     hasLocalIndex() {
         const meta = CodebaseIndexer.loadMeta(this.workspaceRoot);
@@ -114,7 +130,7 @@ export class CodebaseIndexer {
             }
             // Empty workspaces still receive a deterministic, valid SHA-256 value.
             const indexHash = contentHasher.digest('hex');
-            const topFiles = files.slice(0, 12).map((filePath) => path.relative(this.workspaceRoot, filePath));
+            const topFiles = contentEntries.slice(0, 12).map(([relativePath]) => relativePath);
             const meta = {
                 indexedFileCount: this.indexedFileCount,
                 totalChunks: this.totalChunks,
@@ -239,6 +255,8 @@ export class CodebaseIndexer {
             if (!stat.isFile() || stat.size > this.maxFileSize || stat.size === 0)
                 return;
             const content = fs.readFileSync(filePath, 'utf8');
+            if (containsHighConfidenceSecret(content))
+                return;
             const hash = crypto.createHash('md5').update(content).digest('hex');
             if (this.fileHashes.get(filePath) === hash)
                 return;
@@ -320,9 +338,11 @@ export class CodebaseIndexer {
         return map[ext] || 'text';
     }
     shouldIgnore(name, fullPath) {
-        if (name.startsWith('.') && name !== '.env')
+        if (name.startsWith('.'))
             return true;
         const relativePath = path.relative(this.workspaceRoot, fullPath);
+        if (isSensitivePath(relativePath))
+            return true;
         const segments = relativePath.split(path.sep).map((segment) => segment.toLowerCase());
         const fileName = segments.at(-1) || '';
         const suffixPatterns = new Set(['.vsix', '.map', '.min.js', '.min.css']);

package/dist/utils/command-contract.d.ts

@@ -0,0 +1,61 @@
+export type CliErrorCategory = 'usage' | 'configuration' | 'authentication' | 'authorization' | 'network' | 'execution' | 'partial_mutation' | 'cancelled' | 'internal';
+export declare const CLI_EXIT: {
+    readonly success: 0;
+    readonly failure: 1;
+    readonly usage: 2;
+    readonly partialMutation: 3;
+    readonly cancelled: 130;
+};
+export interface NormalizedCliError {
+    code: string;
+    category: CliErrorCategory;
+    message: string;
+    exitCode: number;
+    status?: number;
+    details?: unknown;
+    partialMutation: boolean | 'unknown';
+}
+export interface CliJsonEnvelope<T = unknown> {
+    success: boolean;
+    command: string;
+    data: T | null;
+    error: null | {
+        code: string;
+        category: CliErrorCategory;
+        message: string;
+        details?: unknown;
+    };
+    warnings: string[];
+    metadata: Record<string, unknown>;
+    partialMutation: boolean | 'unknown';
+}
+export declare class CliCommandError extends Error {
+    readonly code: string;
+    readonly category: CliErrorCategory;
+    readonly exitCode: number;
+    readonly status?: number;
+    readonly details?: unknown;
+    readonly partialMutation: boolean | 'unknown';
+    constructor(message: string, options?: {
+        code?: string;
+        category?: CliErrorCategory;
+        exitCode?: number;
+        status?: number;
+        details?: unknown;
+        partialMutation?: boolean | 'unknown';
+        cause?: unknown;
+    });
+}
+export declare function commandFailure(error: unknown, options: {
+    code: string;
+    category?: CliErrorCategory;
+    message?: string;
+    details?: unknown;
+    partialMutation?: boolean | 'unknown';
+}): CliCommandError;
+export declare function exitCodeForCategory(category: CliErrorCategory): number;
+export declare function normalizeCommandError(error: unknown, sanitizeMessage?: (message: string) => string): NormalizedCliError;
+export declare function commandNameFromArgv(argv: readonly string[]): string;
+export declare function failureEnvelope(command: string, error: NormalizedCliError): CliJsonEnvelope;
+export declare function successEnvelope<T>(command: string, data: T, metadata?: Record<string, unknown>, warnings?: string[]): CliJsonEnvelope<T>;
+export declare function formatSuccessJson<T>(command: string, data: T, metadata?: Record<string, unknown>, warnings?: string[]): string;

package/dist/utils/command-contract.js

@@ -0,0 +1,149 @@
+import { redactSensitiveText, redactSensitiveValue } from './secret-policy.js';
+export const CLI_EXIT = {
+    success: 0,
+    failure: 1,
+    usage: 2,
+    partialMutation: 3,
+    cancelled: 130,
+};
+export class CliCommandError extends Error {
+    code;
+    category;
+    exitCode;
+    status;
+    details;
+    partialMutation;
+    constructor(message, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = 'CliCommandError';
+        this.code = options.code || 'CLI_EXECUTION_FAILED';
+        this.category = options.category || 'execution';
+        this.exitCode = options.exitCode ?? exitCodeForCategory(this.category);
+        this.status = options.status;
+        this.details = options.details;
+        this.partialMutation = options.partialMutation ?? false;
+    }
+}
+export function commandFailure(error, options) {
+    if (error instanceof CliCommandError)
+        return error;
+    const normalized = normalizeCommandError(error);
+    return new CliCommandError(options.message || normalized.message, {
+        code: options.code,
+        category: options.category || normalized.category,
+        status: normalized.status,
+        details: options.details ?? normalized.details,
+        partialMutation: options.partialMutation ?? normalized.partialMutation,
+        cause: error,
+    });
+}
+export function exitCodeForCategory(category) {
+    if (category === 'usage' || category === 'configuration')
+        return CLI_EXIT.usage;
+    if (category === 'partial_mutation')
+        return CLI_EXIT.partialMutation;
+    if (category === 'cancelled')
+        return CLI_EXIT.cancelled;
+    return CLI_EXIT.failure;
+}
+function inferCategory(code, status) {
+    const normalized = code.toLowerCase();
+    if (normalized.startsWith('commander.') || /usage|invalid_(?:argument|option|command)/.test(normalized))
+        return 'usage';
+    if (/config|endpoint/.test(normalized))
+        return 'configuration';
+    if (status === 401 || /auth(?:entication)?|token/.test(normalized))
+        return 'authentication';
+    if (status === 403 || /authorization|forbidden|permission/.test(normalized))
+        return 'authorization';
+    if (/offline|network|timeout|untrusted_endpoint|unsafe_redirect|credential_audience/.test(normalized))
+        return 'network';
+    if (/partial/.test(normalized))
+        return 'partial_mutation';
+    if (/cancel/.test(normalized))
+        return 'cancelled';
+    return 'execution';
+}
+export function normalizeCommandError(error, sanitizeMessage = redactSensitiveText) {
+    if (error instanceof CliCommandError) {
+        return {
+            code: error.code,
+            category: error.category,
+            message: sanitizeMessage(error.message),
+            exitCode: error.exitCode,
+            status: error.status,
+            details: redactSensitiveValue(error.details),
+            partialMutation: error.partialMutation,
+        };
+    }
+    const value = error && typeof error === 'object' ? error : {};
+    const response = value.response && typeof value.response === 'object' ? value.response : {};
+    const responseData = response.data && typeof response.data === 'object' ? response.data : {};
+    const rawCode = value.code;
+    const code = typeof rawCode === 'string' && rawCode.trim() ? rawCode : 'CLI_EXECUTION_FAILED';
+    const statusCandidate = value.status ?? value.statusCode ?? response.status;
+    const status = typeof statusCandidate === 'number' ? statusCandidate : undefined;
+    const responseMessage = typeof responseData.error === 'string'
+        ? responseData.error
+        : typeof responseData.message === 'string' ? responseData.message : undefined;
+    const rawMessage = responseMessage
+        || (error instanceof Error
+            ? error.message
+            : typeof error === 'string'
+                ? error
+                : typeof value.message === 'string'
+                    ? value.message
+                    : '')
+        || 'An unexpected CLI error occurred.';
+    const partialMutation = value.partialMutation === true || value.partialMutation === 'unknown'
+        ? value.partialMutation
+        : false;
+    const category = partialMutation === true || partialMutation === 'unknown'
+        ? 'partial_mutation'
+        : inferCategory(code, status);
+    return {
+        code,
+        category,
+        message: sanitizeMessage(rawMessage),
+        // Only CliCommandError may override the public exit contract. Foreign
+        // errors (including Commander's historical exitCode=1 usage errors) are
+        // classified here so implementation details cannot leak into the shell API.
+        exitCode: exitCodeForCategory(category),
+        status,
+        details: redactSensitiveValue(value.details ?? response.data),
+        partialMutation: partialMutation || category === 'partial_mutation',
+    };
+}
+export function commandNameFromArgv(argv) {
+    return argv.slice(2).find((entry) => !entry.startsWith('-')) || 'vigthoria';
+}
+export function failureEnvelope(command, error) {
+    return {
+        success: false,
+        command,
+        data: null,
+        error: {
+            code: error.code,
+            category: error.category,
+            message: error.message,
+            ...(error.details === undefined ? {} : { details: error.details }),
+        },
+        warnings: [],
+        metadata: error.status === undefined ? {} : { httpStatus: error.status },
+        partialMutation: error.partialMutation,
+    };
+}
+export function successEnvelope(command, data, metadata = {}, warnings = []) {
+    return {
+        success: true,
+        command,
+        data,
+        error: null,
+        warnings,
+        metadata,
+        partialMutation: false,
+    };
+}
+export function formatSuccessJson(command, data, metadata = {}, warnings = []) {
+    return JSON.stringify(successEnvelope(command, data, metadata, warnings), null, 2);
+}

package/dist/utils/command-policy.d.ts

@@ -0,0 +1,10 @@
+export type CommandAuthRequirement = 'none' | 'optional-session' | 'required-session';
+export declare const KNOWN_COMMAND_AUTH_PATHS: Set<string>;
+export declare function commandAuthRequirement(commandPath: string): CommandAuthRequirement;
+export declare function commanderCommandPath(command: {
+    name(): string;
+    parent?: {
+        name(): string;
+        parent?: unknown;
+    } | null;
+}): string;

package/dist/utils/command-policy.js

@@ -0,0 +1,54 @@
+const REQUIRED_SESSION_PATHS = new Set([
+    'chat', 'chat-resume', 'agent', 'operator',
+    'edit', 'generate', 'explain', 'fix', 'review',
+    'workflow templates', 'workflow list', 'workflow use-template', 'workflow run', 'workflow status',
+    'hub activate', 'hub active',
+    'repo push', 'repo review', 'repo pull', 'repo list', 'repo status', 'repo share', 'repo delete', 'repo open-in',
+    'background start', 'background list', 'background status', 'background apply', 'background cancel', 'background approve',
+    'deploy', 'deploy preview', 'deploy subdomain', 'deploy custom', 'deploy list', 'deploy status', 'deploy verify', 'deploy remove',
+    'history', 'replay', 'fork', 'cancel',
+]);
+const OPTIONAL_SESSION_PATHS = new Set([
+    'legion',
+]);
+const NO_SESSION_PATHS = new Set([
+    'v4', 'v4-menu', 'bridge', 'bridge status',
+    'device', 'device status', 'device list', 'device screenshot', 'device install', 'device launch', 'device logs', 'device tcpip', 'device connect', 'device disconnect',
+    'security', 'security scan', 'security score', 'security fix',
+    'workflow',
+    'hub', 'hub discover', 'hub list', 'hub search', 'hub info',
+    'music', 'music generate', 'music status',
+    'repo', 'repo clone',
+    'background',
+    'deploy plans', 'preview',
+    'game', 'game init', 'game run', 'game validate',
+    'login', 'logout', 'status', 'auth', 'auth login', 'auth logout', 'auth whoami',
+    'wallet', 'wallet balance', 'wallet history', 'wallet cloud-status',
+    'doctor', 'config', 'update',
+    'hyper-loop', 'hyper-loop status', 'devtools', 'devtools status',
+    'init', 'menu', 'commands',
+]);
+export const KNOWN_COMMAND_AUTH_PATHS = new Set([
+    ...REQUIRED_SESSION_PATHS,
+    ...OPTIONAL_SESSION_PATHS,
+    ...NO_SESSION_PATHS,
+]);
+export function commandAuthRequirement(commandPath) {
+    const normalized = String(commandPath || '').trim().replace(/\s+/g, ' ');
+    if (REQUIRED_SESSION_PATHS.has(normalized))
+        return 'required-session';
+    if (OPTIONAL_SESSION_PATHS.has(normalized))
+        return 'optional-session';
+    if (NO_SESSION_PATHS.has(normalized))
+        return 'none';
+    throw new Error(`Missing authentication policy for command path: ${normalized || '<empty>'}`);
+}
+export function commanderCommandPath(command) {
+    const parts = [];
+    let current = command;
+    while (current?.parent) {
+        parts.unshift(current.name());
+        current = current.parent;
+    }
+    return parts.join(' ');
+}

package/dist/utils/config.d.ts

@@ -42,20 +42,26 @@ export interface AvailableModelDescriptor {
     tier: string;
     backendModel: string;
 }
+export interface ConfigOptions {
+    stateRoot?: string;
+    legacyConfPath?: string;
+}
 export declare class Config {
     private store;
     private static readonly OPERATOR_PLANS;
-    private static readonly CLOUD_PLANS;
-    constructor();
+    constructor(options?: ConfigOptions);
+    private retireLegacyConfStore;
     /**
      * Re-apply secure POSIX permissions to the on-disk config file.  Safe
      * to call repeatedly; no-op on Windows.
      */
     secureOnDisk(): void;
+    private validateEndpointValue;
     get<K extends keyof VigthoriaCLIConfig>(key: K): VigthoriaCLIConfig[K];
     set<K extends keyof VigthoriaCLIConfig>(key: K, value: VigthoriaCLIConfig[K]): void;
     getAll(): VigthoriaCLIConfig;
     reset(): void;
+    resetPreservingAuth(): void;
     isAuthenticated(): boolean;
     hasValidSubscription(): boolean;
     getNormalizedPlan(): string;
@@ -64,9 +70,11 @@ export declare class Config {
     getConfigPath(): string;
     setAuth(data: {
         token: string;
-        refreshToken?: string;
-        userId: string;
-        email: string;
+        refreshToken?: string | null;
+        userId?: string | null;
+        email?: string | null;
+        apiUrl?: string;
+        v3ServiceKey?: string | null;
     }): void;
     clearAuth(): void;
     setSubscription(data: {