vigthoria-cli 1.13.20 → 1.13.23

package/dist/commands/index.js

@@ -1,194 +0,0 @@
-import { registerAuthCommands } from './auth.js';
-import { BridgeCommand } from './bridge.js';
-import { CancelCommand } from './cancel.js';
-import { ChatCommand } from './chat.js';
-import { ConfigCommand } from './config.js';
-import { DeployCommand } from './deploy.js';
-import { EditCommand } from './edit.js';
-import { ExplainCommand } from './explain.js';
-import { ForkCommand } from './fork.js';
-import { GenerateCommand } from './generate.js';
-import { HistoryCommand } from './history.js';
-import { HubCommand } from './hub.js';
-import { LegionCommand } from './legion.js';
-import { MusicCommand } from './music.js';
-import { PreviewCommand } from './preview.js';
-import { ReplayCommand } from './replay.js';
-import { RepoCommand } from './repo.js';
-import { ReviewCommand } from './review.js';
-import { WorkflowCommand } from './workflow.js';
-import { V4Command } from './v4.js';
-import { WalletCommand } from './wallet.js';
-function isRegisterableCommand(value) {
-    return Boolean(value && typeof value === 'object');
-}
-function invokeRegistrar(instance, program) {
-    if (!isRegisterableCommand(instance)) {
-        throw new Error('Command instance is not registerable');
-    }
-    const registrar = instance.register ?? instance.setup ?? instance.configure;
-    if (typeof registrar !== 'function') {
-        throw new Error('Command does not expose register(), setup(), or configure()');
-    }
-    registrar.call(instance, program);
-}
-function createClassRegistrar(CommandClass) {
-    return (program) => {
-        invokeRegistrar(new CommandClass(), program);
-    };
-}
-function registerDoctorCommand(program) {
-    program
-        .command('doctor')
-        .description('Run local Vigthoria CLI diagnostics')
-        .action(() => {
-        const checks = [
-            ['Node.js', process.version],
-            ['Platform', `${process.platform} ${process.arch}`],
-            ['Working directory', process.cwd()],
-        ];
-        console.log('Vigthoria CLI diagnostics');
-        for (const [label, value] of checks) {
-            console.log(`- ${label}: ${value}`);
-        }
-    });
-}
-function registerVersionInfoCommand(program) {
-    program
-        .command('version-info')
-        .description('Show runtime version information')
-        .action(() => {
-        console.log(JSON.stringify({
-            node: process.version,
-            platform: process.platform,
-            arch: process.arch,
-            argv0: process.argv0,
-        }, null, 2));
-    });
-}
-const commandRegistry = [
-    {
-        name: 'auth',
-        handler: registerAuthCommands,
-    },
-    {
-        name: 'chat',
-        handler: createClassRegistrar(ChatCommand),
-    },
-    {
-        name: 'edit',
-        handler: createClassRegistrar(EditCommand),
-    },
-    {
-        name: 'generate',
-        handler: createClassRegistrar(GenerateCommand),
-    },
-    {
-        name: 'explain',
-        handler: createClassRegistrar(ExplainCommand),
-    },
-    {
-        name: 'config',
-        handler: createClassRegistrar(ConfigCommand),
-    },
-    {
-        name: 'review',
-        handler: createClassRegistrar(ReviewCommand),
-    },
-    {
-        name: 'hub',
-        handler: createClassRegistrar(HubCommand),
-    },
-    {
-        name: 'music',
-        aliases: ['audio'],
-        handler: createClassRegistrar(MusicCommand),
-    },
-    {
-        name: 'repo',
-        handler: createClassRegistrar(RepoCommand),
-    },
-    {
-        name: 'deploy',
-        handler: createClassRegistrar(DeployCommand),
-    },
-    {
-        name: 'bridge',
-        handler: createClassRegistrar(BridgeCommand),
-    },
-    {
-        name: 'v4',
-        aliases: ['v4-agent'],
-        handler: createClassRegistrar(V4Command),
-    },
-    {
-        name: 'workflow',
-        handler: createClassRegistrar(WorkflowCommand),
-    },
-    {
-        name: 'preview',
-        handler: createClassRegistrar(PreviewCommand),
-    },
-    {
-        name: 'legion',
-        handler: createClassRegistrar(LegionCommand),
-    },
-    {
-        name: 'history',
-        handler: createClassRegistrar(HistoryCommand),
-    },
-    {
-        name: 'wallet',
-        handler: createClassRegistrar(WalletCommand),
-    },
-    {
-        name: 'replay',
-        handler: createClassRegistrar(ReplayCommand),
-    },
-    {
-        name: 'fork',
-        handler: createClassRegistrar(ForkCommand),
-    },
-    {
-        name: 'cancel',
-        handler: createClassRegistrar(CancelCommand),
-    },
-    {
-        name: 'doctor',
-        handler: registerDoctorCommand,
-    },
-    {
-        name: 'version-info',
-        aliases: ['versionInfo'],
-        handler: registerVersionInfoCommand,
-    },
-];
-function normalizeCommandName(name) {
-    return name.trim().toLowerCase();
-}
-function commandNameMatches(entry, requestedName) {
-    if (normalizeCommandName(entry.name) === requestedName) {
-        return true;
-    }
-    return Boolean(entry.aliases?.some((alias) => normalizeCommandName(alias) === requestedName));
-}
-export function resolveCommand(name) {
-    const requestedName = normalizeCommandName(name);
-    if (!requestedName) {
-        return null;
-    }
-    const entry = commandRegistry.find((candidate) => commandNameMatches(candidate, requestedName));
-    return entry?.handler ?? null;
-}
-export function registerCommands(cli) {
-    if (!cli || typeof cli.command !== 'function') {
-        throw new Error('registerCommands requires a Commander-compatible CLI instance');
-    }
-    const program = cli;
-    for (const entry of commandRegistry) {
-        entry.handler(program);
-    }
-}
-export const setupCommands = registerCommands;
-export const configureCommands = registerCommands;
-export default registerCommands;

package/dist/commands/update.d.ts

@@ -1,9 +0,0 @@
-type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun';
-interface UpdateOptions {
-    check?: boolean;
-    packageManager?: PackageManager;
-    global?: boolean;
-}
-export declare function updateCommand(options?: UpdateOptions): Promise<void>;
-export declare function update(): Promise<void>;
-export default updateCommand;

package/dist/commands/update.js

@@ -1,301 +0,0 @@
-import { execFile } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { promisify } from 'node:util';
-// ESM shim — __filename is unavailable under "type": "module".
-const __filename = fileURLToPath(import.meta.url);
-const execFileAsync = promisify(execFile);
-const DEFAULT_UPDATE_MANIFEST = 'https://extension.vigthoria.io/downloads/manifest.json';
-const TRUSTED_RELEASE_HOSTS = new Set([
-    'extension.vigthoria.io',
-    'landing.vigthoria.io',
-    'cli.vigthoria.io',
-    'coder.vigthoria.io',
-    'market.vigthoria.io',
-]);
-function markSuccessExit() {
-    process.exitCode = 0;
-}
-function markErrorExit() {
-    process.exitCode = 1;
-}
-function findPackageJson(startDir) {
-    let currentDir = startDir;
-    for (let depth = 0; depth < 8; depth += 1) {
-        const candidate = path.join(currentDir, 'package.json');
-        if (existsSync(candidate)) {
-            return candidate;
-        }
-        const parentDir = path.join(currentDir, '..');
-        if (parentDir === currentDir) {
-            break;
-        }
-        currentDir = parentDir;
-    }
-    return null;
-}
-function readOwnPackageJson() {
-    const currentFile = __filename;
-    const packagePath = findPackageJson(path.join(currentFile, '..'));
-    if (!packagePath) {
-        throw new Error('Unable to locate package.json for the Vigthoria CLI.');
-    }
-    try {
-        return JSON.parse(readFileSync(packagePath, 'utf8'));
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Unable to read package metadata: ${message}`);
-    }
-}
-function compareVersions(a, b) {
-    const parse = (version) => version.replace(/^v/, '').split(/[.-]/).map((part) => {
-        const value = Number.parseInt(part, 10);
-        return Number.isNaN(value) ? 0 : value;
-    });
-    const left = parse(a);
-    const right = parse(b);
-    const length = Math.max(left.length, right.length);
-    for (let index = 0; index < length; index += 1) {
-        const leftValue = left[index] ?? 0;
-        const rightValue = right[index] ?? 0;
-        if (leftValue > rightValue)
-            return 1;
-        if (leftValue < rightValue)
-            return -1;
-    }
-    return 0;
-}
-function quoteCmdArg(value) {
-    if (!/[\s"&()<>^|]/.test(value)) {
-        return value;
-    }
-    return `"${value.replace(/(\\*)"/g, '$1$1\\"')}"`;
-}
-function toPlatformCommand(command, args) {
-    if (process.platform !== 'win32') {
-        return { command, args };
-    }
-    const cmdPath = process.env.ComSpec || path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'cmd.exe');
-    return {
-        command: cmdPath,
-        args: ['/d', '/s', '/c', [command, ...args].map(quoteCmdArg).join(' ')],
-    };
-}
-async function execPackageManager(command, args, timeout) {
-    const platformCommand = toPlatformCommand(command, args);
-    const { stdout } = await execFileAsync(platformCommand.command, platformCommand.args, {
-        timeout,
-        maxBuffer: 1024 * 1024,
-        windowsHide: true,
-    });
-    return stdout;
-}
-async function getLatestVersion(packageName) {
-    try {
-        const stdout = await execPackageManager('npm', ['view', packageName, 'version'], 30_000);
-        const latest = stdout.trim();
-        if (!latest) {
-            throw new Error('npm returned an empty version response');
-        }
-        return latest;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Unable to check the latest published version: ${message}`);
-    }
-}
-function validateTrustedHttpsUrl(value, label) {
-    let parsed;
-    try {
-        parsed = new URL(value);
-    }
-    catch {
-        throw new Error(`${label} is not a valid URL`);
-    }
-    if (parsed.protocol !== 'https:' || !TRUSTED_RELEASE_HOSTS.has(parsed.hostname)) {
-        throw new Error(`${label} must use HTTPS on an approved Vigthoria release host`);
-    }
-    return parsed;
-}
-async function getStableRelease() {
-    const manifestUrl = process.env.VIGTHORIA_UPDATE_MANIFEST_URL
-        || DEFAULT_UPDATE_MANIFEST;
-    validateTrustedHttpsUrl(manifestUrl, 'Update manifest URL');
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 20_000);
-    try {
-        const response = await fetch(manifestUrl, {
-            headers: { Accept: 'application/json' },
-            redirect: 'follow',
-            signal: controller.signal,
-        });
-        if (!response.ok) {
-            throw new Error(`manifest returned HTTP ${response.status}`);
-        }
-        validateTrustedHttpsUrl(response.url || manifestUrl, 'Resolved manifest URL');
-        const document = await response.json();
-        const stable = document.channels?.stable;
-        const version = String(stable?.version || '').trim();
-        const url = String(stable?.url || '').trim();
-        const sha256 = String(stable?.sha256 || '').trim().toLowerCase();
-        if (!/^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?$/.test(version)) {
-            throw new Error('stable manifest version is invalid');
-        }
-        validateTrustedHttpsUrl(url, 'Stable release URL');
-        if (!/^[a-f0-9]{64}$/.test(sha256)) {
-            throw new Error('stable release SHA-256 is missing or invalid');
-        }
-        return { version, url, sha256 };
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
-async function getVersionInfo() {
-    const packageJson = readOwnPackageJson();
-    const packageName = packageJson.name;
-    const current = packageJson.version;
-    if (!packageName || !current) {
-        throw new Error('The CLI package metadata must include both name and version.');
-    }
-    let release;
-    let latest;
-    try {
-        release = await getStableRelease();
-        latest = release.version;
-    }
-    catch (manifestError) {
-        const reason = manifestError instanceof Error
-            ? manifestError.message
-            : String(manifestError);
-        console.warn(`Verified release manifest unavailable (${reason}); checking npm.`);
-        latest = await getLatestVersion(packageName);
-    }
-    return {
-        current,
-        latest,
-        packageName,
-        updateAvailable: compareVersions(current, latest) < 0,
-        release,
-    };
-}
-function resolveInstallTargetCommand(packageManager, target, installGlobal) {
-    switch (packageManager) {
-        case 'pnpm':
-            return { command: 'pnpm', args: installGlobal ? ['add', '--global', target] : ['add', '-D', target] };
-        case 'yarn':
-            return { command: 'yarn', args: installGlobal ? ['global', 'add', target] : ['add', '--dev', target] };
-        case 'bun':
-            return { command: 'bun', args: installGlobal ? ['add', '--global', target] : ['add', '--dev', target] };
-        case 'npm':
-        default:
-            return { command: 'npm', args: installGlobal ? ['install', '--global', target] : ['install', '--save-dev', target] };
-    }
-}
-function resolveInstallCommand(packageManager, packageName, installGlobal) {
-    return resolveInstallTargetCommand(packageManager, `${packageName}@latest`, installGlobal);
-}
-function formatCommand(command) {
-    return [command.command, ...command.args].map(quoteCmdArg).join(' ');
-}
-async function runInstall(packageManager, packageName, installGlobal) {
-    const installCommand = resolveInstallCommand(packageManager, packageName, installGlobal);
-    await execPackageManager(installCommand.command, installCommand.args, 120_000);
-}
-async function downloadVerifiedRelease(release) {
-    const directory = await mkdtemp(path.join(tmpdir(), 'vigthoria-cli-update-'));
-    const archive = path.join(directory, `vigthoria-cli-${release.version}.tgz`);
-    try {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 60_000);
-        let response;
-        try {
-            response = await fetch(release.url, {
-                redirect: 'follow',
-                signal: controller.signal,
-            });
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-        if (!response.ok) {
-            throw new Error(`release download returned HTTP ${response.status}`);
-        }
-        validateTrustedHttpsUrl(response.url || release.url, 'Resolved release URL');
-        const bytes = Buffer.from(await response.arrayBuffer());
-        const digest = createHash('sha256').update(bytes).digest('hex');
-        if (digest !== release.sha256) {
-            throw new Error(`release checksum mismatch (expected ${release.sha256}, received ${digest})`);
-        }
-        await writeFile(archive, bytes, { mode: 0o600 });
-        return { directory, archive };
-    }
-    catch (error) {
-        await rm(directory, { recursive: true, force: true });
-        throw error;
-    }
-}
-export async function updateCommand(options = {}) {
-    try {
-        const info = await getVersionInfo();
-        console.log(`Vigthoria CLI current version: ${info.current}`);
-        console.log(`Vigthoria CLI latest version:  ${info.latest}`);
-        if (!info.updateAvailable) {
-            console.log('You are already running the latest Vigthoria CLI.');
-            markSuccessExit();
-            return;
-        }
-        console.log(`Update available for ${info.packageName}: ${info.current} → ${info.latest}`);
-        if (options.check) {
-            markSuccessExit();
-            return;
-        }
-        const packageManager = options.packageManager ?? 'npm';
-        const installGlobal = options.global ?? true;
-        if (info.release) {
-            console.log(`Installing checksum-verified ${info.packageName}@${info.release.version} `
-                + `with ${packageManager}...`);
-            const downloaded = await downloadVerifiedRelease(info.release);
-            try {
-                const installCommand = resolveInstallTargetCommand(packageManager, downloaded.archive, installGlobal);
-                await execPackageManager(installCommand.command, installCommand.args, 120_000);
-            }
-            finally {
-                await rm(downloaded.directory, { recursive: true, force: true });
-            }
-            console.log('Verified release installation finished successfully.');
-        }
-        else {
-            console.log(`Installing ${info.packageName}@latest with ${packageManager}...`);
-            await runInstall(packageManager, info.packageName, installGlobal);
-            console.log('Package manager installation finished successfully.');
-        }
-        console.log('Vigthoria CLI update complete.');
-        markSuccessExit();
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`Update failed: ${message}`);
-        markErrorExit();
-    }
-}
-export async function update() {
-    try {
-        await updateCommand();
-        if (process.exitCode === 1) {
-            return;
-        }
-        markSuccessExit();
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`Update failed: ${message}`);
-        markErrorExit();
-    }
-}
-export default updateCommand;

package/dist/utils/templateInstantPath.d.ts

@@ -1,18 +0,0 @@
-/**
- * Sub-second path: Template Service match → write index.html (skip V3 planner).
- */
-import type { APIClient } from './api.js';
-export type TemplateInstantResult = {
-    ok: boolean;
-    entryPath?: string;
-    templateName?: string;
-    confidence?: number;
-    processingMs?: number;
-    error?: string;
-    usedFallback?: boolean;
-};
-export declare function runTemplateInstantPath(api: APIClient, vision: string, workspacePath: string, options?: {
-    entryPath?: string;
-    allowFallback?: boolean;
-    forceMinimalFallback?: boolean;
-}): Promise<TemplateInstantResult>;