crewx 0.8.7-rc.21 → 0.8.7-rc.22

package/dist-server/domain/cli/cli.service.js

@@ -1,598 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CliService = void 0;
-exports.getShellEnv = getShellEnv;
-exports.resetShellEnvCache = resetShellEnvCache;
-exports.filterNodeModulesBin = filterNodeModulesBin;
-exports.resolveCliPathGuard = resolveCliPathGuard;
-exports.execCommand = execCommand;
-exports.parseVersion = parseVersion;
-exports.isOlderVersion = isOlderVersion;
-exports.findLatestVersion = findLatestVersion;
-const common_1 = require("@nestjs/common");
-const child_process_1 = require("child_process");
-const fs_1 = require("fs");
-const os_1 = require("os");
-const path_1 = require("path");
-const util_1 = require("util");
-const execAsync = (0, util_1.promisify)(child_process_1.exec);
-const isWindows = process.platform === 'win32';
-const logger = new common_1.Logger('CliService');
-// Cache the shell env Promise (not the value) to prevent race conditions.
-// Multiple concurrent callers will await the same promise instead of
-// each spawning their own interactive shell.
-let envPromise = null;
-function parseEnvOutput(stdout) {
-    const env = {};
-    for (const line of stdout.split('\n')) {
-        const idx = line.indexOf('=');
-        if (idx > 0) {
-            env[line.slice(0, idx)] = line.slice(idx + 1);
-        }
-    }
-    return env;
-}
-async function tryShellEnv(shell, flags) {
-    try {
-        const { stdout } = await execAsync(`${shell} ${flags} 'env'`, { timeout: 10000 });
-        const env = parseEnvOutput(stdout);
-        if (env.PATH && env.PATH !== process.env.PATH) {
-            return env;
-        }
-        return env;
-    }
-    catch (err) {
-        logger.debug(`Shell env detection failed with "${shell} ${flags}": ${err instanceof Error ? err.message : err}`);
-        return null;
-    }
-}
-// Resolves the user's shell environment once; subsequent calls return the same promise.
-function getShellEnv() {
-    if (envPromise)
-        return envPromise;
-    envPromise = (async () => {
-        if (isWindows) {
-            return process.env;
-        }
-        const shell = process.env.SHELL || '/bin/bash';
-        const strategies = [
-            { flags: '-ic', desc: 'interactive' },
-            { flags: '-lc', desc: 'login' },
-        ];
-        for (const { flags, desc } of strategies) {
-            const env = await tryShellEnv(shell, flags);
-            if (env) {
-                const merged = { ...process.env, ...env };
-                logger.log(`Detected shell env via ${shell} ${flags} (${desc})`);
-                logger.log(`Detected shell env PATH: ${merged.PATH?.substring(0, 200)}...`);
-                return merged;
-            }
-        }
-        logger.warn('Shell env detection failed for all strategies, using process.env');
-        return process.env;
-    })();
-    return envPromise;
-}
-// Reset the cached env promise (useful for testing)
-function resetShellEnvCache() {
-    envPromise = null;
-}
-function getUserShell() {
-    return process.env.SHELL || '/bin/zsh';
-}
-// Removes cwd/node_modules/.bin from a PATH string to prevent local shims
-// from shadowing globally-installed CLIs (Windows-primary issue; applied
-// conservatively on both platforms).
-function filterNodeModulesBin(pathStr, cwd) {
-    const localBin = (0, path_1.resolve)(cwd, 'node_modules', '.bin');
-    const separator = isWindows ? ';' : ':';
-    return pathStr
-        .split(separator)
-        .filter((p) => {
-        if (!p)
-            return true;
-        const normalized = (0, path_1.resolve)(p);
-        return isWindows
-            ? normalized.toLowerCase() !== localBin.toLowerCase()
-            : normalized !== localBin;
-    })
-        .join(separator);
-}
-// Returns null when resolvedPath is under cwd/node_modules (local shim guard).
-function resolveCliPathGuard(rawPath, cwd) {
-    if (!rawPath)
-        return null;
-    const nodeModulesDir = (0, path_1.resolve)(cwd, 'node_modules');
-    const normalized = (0, path_1.resolve)(rawPath);
-    const prefix = nodeModulesDir + path_1.sep;
-    if (isWindows) {
-        if (normalized.toLowerCase().startsWith(prefix.toLowerCase()) || normalized.toLowerCase() === nodeModulesDir.toLowerCase()) {
-            return null;
-        }
-    }
-    else {
-        if (normalized.startsWith(prefix) || normalized === nodeModulesDir) {
-            return null;
-        }
-    }
-    return rawPath;
-}
-// Execute a command inside the user's actual login shell so that
-// PATH ordering (nvm, homebrew, etc.) matches what the user sees
-// in their terminal.
-async function execCommand(cmd, timeout = 10000) {
-    if (isWindows) {
-        // Strip cwd/node_modules/.bin from PATH so local shims (e.g. transitive
-        // @openai/codex installed via peerDeps) cannot shadow global CLIs.
-        const env = {};
-        for (const [k, v] of Object.entries(process.env)) {
-            if (v !== undefined)
-                env[k] = v;
-        }
-        if (env.PATH) {
-            env.PATH = filterNodeModulesBin(env.PATH, process.cwd());
-        }
-        return execAsync(cmd, { timeout, shell: process.env.ComSpec || 'cmd.exe', env });
-    }
-    const shell = getUserShell();
-    // Use -ilc (interactive + login) so zsh builds PATH from scratch
-    // via .zprofile + .zshrc, not inheriting VSCode's polluted env.
-    // Unix: minimal env with no PATH means the shell rebuilds it via -ilc;
-    // node_modules/.bin never appears in the reconstructed PATH.
-    const escapedCmd = cmd.replace(/'/g, "'\\''");
-    return execAsync(`${shell} -ilc '${escapedCmd}'`, {
-        timeout,
-        env: {
-            HOME: process.env.HOME || '',
-            USER: process.env.USER || '',
-            SHELL: process.env.SHELL || shell,
-            TERM: process.env.TERM || 'xterm-256color',
-            DISABLE_AUTO_UPDATE: 'true',
-        },
-    });
-}
-// Parse version string (supports semver with prerelease)
-function parseVersion(versionOutput) {
-    if (!versionOutput)
-        return '';
-    const match = versionOutput.match(/v?(\d+\.\d+\.\d+(?:-[a-zA-Z0-9.]+)?)/);
-    return match ? match[1] : versionOutput.split('\n')[0].slice(0, 30).trim();
-}
-// Compare semver: returns true if v1 < v2 (prerelease-aware)
-function isOlderVersion(v1, v2) {
-    if (!v1 || !v2)
-        return false;
-    const parse = (v) => {
-        const [core, pre] = v.split('-');
-        const parts = core.split('.').map(Number);
-        return { parts, pre: pre || '' };
-    };
-    const a = parse(v1);
-    const b = parse(v2);
-    for (let i = 0; i < 3; i++) {
-        if ((a.parts[i] || 0) < (b.parts[i] || 0))
-            return true;
-        if ((a.parts[i] || 0) > (b.parts[i] || 0))
-            return false;
-    }
-    // Same core: prerelease < release (1.0.0-rc.1 < 1.0.0)
-    if (a.pre && !b.pre)
-        return true;
-    if (!a.pre && b.pre)
-        return false;
-    if (a.pre && b.pre)
-        return a.pre.localeCompare(b.pre, undefined, { numeric: true }) < 0;
-    return false;
-}
-// Pick the highest version from a list of semver strings
-function findLatestVersion(versions) {
-    if (!versions.length)
-        return 'unknown';
-    let latest = versions[0];
-    for (let i = 1; i < versions.length; i++) {
-        if (isOlderVersion(latest, versions[i])) {
-            latest = versions[i];
-        }
-    }
-    return latest;
-}
-// CLI-specific login commands (SSOT)
-// NOTE: commands must be non-interactive (no stdin prompts) — they run with stdio:'ignore'
-const LOGIN_COMMANDS = {
-    claude: 'claude auth login',
-    gemini: 'gemini', // first launch triggers Google OAuth browser flow
-    codex: 'codex login',
-    copilot: 'gh auth login --web -h github.com -p https',
-};
-const CLI_LIST = [
-    {
-        name: 'claude',
-        displayName: 'Claude Code',
-        provider: 'Anthropic',
-        packageName: '@anthropic-ai/claude-code',
-        versionCommand: 'claude --version',
-        loginCommand: LOGIN_COMMANDS['claude'],
-        installStrategy: 'npm',
-    },
-    {
-        name: 'codex',
-        displayName: 'Codex CLI',
-        provider: 'OpenAI',
-        packageName: '@openai/codex',
-        versionCommand: 'codex --version',
-        loginCommand: LOGIN_COMMANDS['codex'],
-        installStrategy: 'npm',
-    },
-    {
-        name: 'gemini',
-        displayName: 'Gemini CLI',
-        provider: 'Google',
-        packageName: '@google/gemini-cli',
-        versionCommand: 'gemini --version',
-        loginCommand: LOGIN_COMMANDS['gemini'],
-        installStrategy: 'npm',
-        deprecated: 'Antigravity CLI로 전환하세요 (2026-06-18 종료)',
-    },
-    {
-        name: 'antigravity',
-        displayName: 'Antigravity',
-        provider: 'Google',
-        packageName: '',
-        versionCommand: 'agy --version',
-        loginCommand: null,
-        installStrategy: 'script',
-        installScript: 'curl -fsSL https://antigravity.google/cli/install.sh | bash',
-    },
-    {
-        name: 'copilot',
-        displayName: 'GitHub Copilot',
-        provider: 'GitHub',
-        packageName: '@github/copilot',
-        versionCommand: 'copilot --version',
-        loginCommand: LOGIN_COMMANDS['copilot'],
-        installStrategy: 'npm',
-    },
-    {
-        name: 'opencode',
-        displayName: 'OpenCode',
-        provider: 'OpenCode',
-        packageName: 'opencode-ai',
-        versionCommand: 'opencode --version',
-        loginCommand: null,
-        installStrategy: 'npm',
-    },
-    {
-        name: 'crewx',
-        displayName: 'CrewX',
-        provider: 'CrewX',
-        packageName: 'crewx',
-        versionCommand: 'crewx --version',
-        loginCommand: null,
-        installStrategy: 'npm',
-    },
-];
-let CliService = class CliService {
-    async getVersions() {
-        const results = [];
-        for (const cli of CLI_LIST) {
-            if (cli.installStrategy === 'script') {
-                const currentVersion = await this.getCurrentVersion(cli.versionCommand);
-                results.push({
-                    name: cli.name,
-                    displayName: cli.displayName,
-                    provider: cli.provider,
-                    installed: currentVersion !== null,
-                    currentVersion,
-                    latestVersion: null,
-                    updateAvailable: false,
-                    packageName: cli.packageName,
-                });
-                continue;
-            }
-            // Primary: global npm (immune to node_modules/.bin shim)
-            let currentVersion = await this.getNpmGlobalVersion(cli.packageName);
-            let installed = currentVersion !== null;
-            // Fallback: --version command (execCommand PATH guard prevents local shim)
-            if (!installed) {
-                currentVersion = await this.getCurrentVersion(cli.versionCommand);
-                installed = currentVersion !== null;
-            }
-            const latestVersion = await this.getLatestVersion(cli.packageName);
-            results.push({
-                name: cli.name,
-                displayName: cli.displayName,
-                provider: cli.provider,
-                installed,
-                currentVersion,
-                latestVersion,
-                updateAvailable: currentVersion !== null && latestVersion !== 'unknown' && isOlderVersion(currentVersion, latestVersion),
-                packageName: cli.packageName,
-            });
-        }
-        return results;
-    }
-    async update(name, version) {
-        const cli = CLI_LIST.find((c) => c.name === name);
-        if (!cli) {
-            throw new common_1.NotFoundException(`CLI not found: ${name}`);
-        }
-        const previousVersion = (await this.getCurrentVersion(cli.versionCommand)) ||
-            (await this.getNpmGlobalVersion(cli.packageName));
-        if (cli.installStrategy === 'script') {
-            return {
-                name: cli.name,
-                previousVersion: previousVersion || 'none',
-                newVersion: previousVersion || 'unknown',
-                message: `${cli.displayName}은 npm으로 업데이트할 수 없습니다. 터미널에서 실행: ${cli.installScript}`,
-            };
-        }
-        const targetVersion = version || 'latest';
-        try {
-            await execCommand(`npm install -g ${cli.packageName}@${targetVersion}`, 60000);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new common_1.InternalServerErrorException(`Update failed: ${errorMessage}`);
-        }
-        // Use npm list as primary source — some CLIs (e.g. copilot) report different versions via --version
-        const newVersion = (await this.getNpmGlobalVersion(cli.packageName)) ||
-            (await this.getCurrentVersion(cli.versionCommand));
-        return {
-            name: cli.name,
-            previousVersion: previousVersion || 'none',
-            newVersion: newVersion || 'unknown',
-            message: `Updated ${cli.displayName} from ${previousVersion || 'none'} to ${newVersion || 'unknown'}`,
-        };
-    }
-    async setupBatch(names, send) {
-        const toInstall = [];
-        const toLogin = [];
-        for (const name of names) {
-            const cli = CLI_LIST.find((c) => c.name === name);
-            if (!cli)
-                continue;
-            if (cli.installStrategy === 'script') {
-                send('log', { cli: cli.name, text: `${cli.displayName} — 수동 설치: ${cli.installScript}`, type: 'output' });
-                continue;
-            }
-            const currentVersion = await this.getCurrentVersion(cli.versionCommand);
-            const installed = currentVersion !== null || !!(await this.getNpmGlobalVersion(cli.packageName));
-            const authenticated = await this.checkAuthenticated(cli.name);
-            if (!installed)
-                toInstall.push(cli);
-            if (authenticated !== true && cli.loginCommand)
-                toLogin.push(cli);
-        }
-        // Phase 1: parallel install
-        if (toInstall.length > 0) {
-            const installPromises = toInstall.map(async (cli) => {
-                send('status', { cli: cli.name, status: 'installing' });
-                send('log', { cli: cli.name, text: `$ npm install -g ${cli.packageName}`, type: 'command' });
-                try {
-                    await execCommand(`npm install -g ${cli.packageName}@latest`, 120000);
-                    send('status', { cli: cli.name, status: 'installed' });
-                    send('log', { cli: cli.name, text: `✔ ${cli.displayName} installed`, type: 'success' });
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    send('status', { cli: cli.name, status: 'failed' });
-                    send('log', { cli: cli.name, text: `✘ ${cli.displayName}: ${msg}`, type: 'error' });
-                }
-            });
-            await Promise.allSettled(installPromises);
-        }
-        // Phase 2: sequential login check (we can't run login commands server-side, just report status)
-        for (const cli of toLogin) {
-            send('status', { cli: cli.name, status: 'login_needed' });
-            send('log', { cli: cli.name, text: `$ ${cli.loginCommand}`, type: 'command' });
-            send('log', { cli: cli.name, text: `Run this command in your terminal to log in`, type: 'output' });
-        }
-    }
-    spawnLogin(name) {
-        const cli = CLI_LIST.find((c) => c.name === name);
-        if (!cli || !cli.loginCommand) {
-            return { name, loginCommand: '', spawned: false };
-        }
-        const child = (0, child_process_1.spawn)(cli.loginCommand, [], {
-            detached: true,
-            stdio: 'ignore',
-            shell: true,
-        });
-        child.unref();
-        return { name: cli.name, loginCommand: cli.loginCommand, spawned: true };
-    }
-    async check(name) {
-        const cli = CLI_LIST.find((c) => c.name === name);
-        if (!cli) {
-            return {
-                name,
-                installed: false,
-                currentVersion: null,
-                latestVersion: 'unknown',
-                path: null,
-                authenticated: null,
-                loginCommand: null,
-            };
-        }
-        if (cli.installStrategy === 'script') {
-            const currentVersion = await this.getCurrentVersion(cli.versionCommand);
-            const authenticated = await this.checkAuthenticated(name);
-            return {
-                name: cli.name,
-                installed: currentVersion !== null,
-                currentVersion,
-                latestVersion: null,
-                path: null,
-                authenticated,
-                loginCommand: cli.loginCommand,
-            };
-        }
-        // Primary: global npm (immune to node_modules/.bin shim)
-        let currentVersion = await this.getNpmGlobalVersion(cli.packageName);
-        let installed = currentVersion !== null;
-        // Fallback: --version command (execCommand PATH guard prevents local shim)
-        if (!installed) {
-            currentVersion = await this.getCurrentVersion(cli.versionCommand);
-            installed = currentVersion !== null;
-        }
-        const latestVersion = await this.getLatestVersion(cli.packageName);
-        const path = await this.getCliPath(cli.versionCommand.split(' ')[0]);
-        const authenticated = await this.checkAuthenticated(cli.name);
-        return {
-            name: cli.name,
-            installed,
-            currentVersion,
-            latestVersion,
-            path,
-            authenticated,
-            loginCommand: cli.loginCommand,
-        };
-    }
-    async checkAuthenticated(cliName) {
-        switch (cliName) {
-            case 'claude':
-                return this.checkClaudeAuth();
-            case 'codex':
-                return this.checkCodexAuth();
-            case 'copilot':
-                return this.checkCopilotAuth();
-            case 'gemini':
-                return this.checkGeminiAuth();
-            case 'antigravity':
-                return null; // 인증 방식 미확정, 실측 후 보완
-            default:
-                return null;
-        }
-    }
-    async checkClaudeAuth() {
-        try {
-            const { stdout } = await execCommand('claude auth status --json', 10000);
-            try {
-                const parsed = JSON.parse(stdout.trim());
-                return parsed.loggedIn === true;
-            }
-            catch {
-                return this.parseAuthString(stdout);
-            }
-        }
-        catch (err) {
-            const e = err;
-            const output = e.stdout || e.stderr || '';
-            const parsed = this.parseAuthString(output);
-            if (parsed !== null)
-                return parsed;
-            return false;
-        }
-    }
-    async checkCodexAuth() {
-        try {
-            const { stdout, stderr } = await execCommand('codex login status', 10000);
-            // codex outputs to stderr
-            const output = stdout || stderr;
-            return this.parseAuthString(output);
-        }
-        catch {
-            // exit != 0 means not logged in
-            return false;
-        }
-    }
-    async checkCopilotAuth() {
-        try {
-            const { stdout, stderr } = await execCommand('gh auth status', 10000);
-            const output = stdout || stderr;
-            const lower = output.toLowerCase();
-            if (lower.includes('logged in'))
-                return true;
-            return false;
-        }
-        catch {
-            // exit != 0 means not logged in
-            return false;
-        }
-    }
-    checkGeminiAuth() {
-        const credsPath = (0, path_1.join)((0, os_1.homedir)(), '.gemini', 'oauth_creds.json');
-        return (0, fs_1.existsSync)(credsPath);
-    }
-    parseAuthString(stdout) {
-        const lower = stdout.toLowerCase();
-        if (lower.includes('not authenticated') || lower.includes('not logged in'))
-            return false;
-        if (lower.includes('logged in') || lower.includes('authenticated'))
-            return true;
-        return null;
-    }
-    async getAvailableVersions(name) {
-        const cli = CLI_LIST.find((c) => c.name === name);
-        if (!cli) {
-            return { name, versions: [] };
-        }
-        if (cli.installStrategy === 'script') {
-            return { name, versions: [] };
-        }
-        try {
-            const { stdout } = await execCommand(`npm view ${cli.packageName} versions --json`, 15000);
-            const parsed = JSON.parse(stdout.trim());
-            // npm returns a single string when only one version exists
-            const all = Array.isArray(parsed) ? parsed : [parsed];
-            // Semver: versions with a hyphen are prerelease (rc, alpha, beta, nightly, platform builds, etc.)
-            const stable = all.filter(v => !v.includes('-'));
-            const versions = stable.reverse().slice(0, 20);
-            return { name, versions };
-        }
-        catch {
-            return { name, versions: [] };
-        }
-    }
-    async getCurrentVersion(command) {
-        try {
-            const { stdout } = await execCommand(command);
-            const version = parseVersion(stdout.trim());
-            return version || null;
-        }
-        catch {
-            return null;
-        }
-    }
-    async getNpmGlobalVersion(packageName) {
-        try {
-            const { stdout } = await execCommand(`npm list -g ${packageName} --depth=0 --json`, 10000);
-            const parsed = JSON.parse(stdout.trim());
-            const version = parsed?.dependencies?.[packageName]?.version;
-            return version || null;
-        }
-        catch {
-            return null;
-        }
-    }
-    async getLatestVersion(packageName) {
-        try {
-            const { stdout } = await execCommand(`npm view ${packageName}@latest version`, 15000);
-            return stdout.trim() || 'unknown';
-        }
-        catch {
-            return 'unknown';
-        }
-    }
-    async getCliPath(command) {
-        try {
-            const cmd = isWindows ? `where ${command}` : `which ${command}`;
-            const { stdout } = await execCommand(cmd);
-            const rawPath = stdout.trim().split('\n')[0];
-            return resolveCliPathGuard(rawPath, process.cwd());
-        }
-        catch {
-            return null;
-        }
-    }
-};
-exports.CliService = CliService;
-exports.CliService = CliService = __decorate([
-    (0, common_1.Injectable)()
-], CliService);

package/dist-server/domain/cli/dto/login-cli.dto.js

@@ -1,25 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoginCliDto = void 0;
-const swagger_1 = require("@nestjs/swagger");
-const class_validator_1 = require("class-validator");
-class LoginCliDto {
-    name;
-}
-exports.LoginCliDto = LoginCliDto;
-__decorate([
-    (0, swagger_1.ApiProperty)({ description: 'CLI tool name', enum: ['claude', 'codex', 'gemini', 'copilot'] }),
-    (0, class_validator_1.IsString)(),
-    (0, class_validator_1.IsNotEmpty)(),
-    (0, class_validator_1.IsIn)(['claude', 'codex', 'gemini', 'copilot']),
-    __metadata("design:type", String)
-], LoginCliDto.prototype, "name", void 0);

package/dist-server/domain/cli/dto/update-cli.dto.js

@@ -1,31 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UpdateCliDto = void 0;
-const swagger_1 = require("@nestjs/swagger");
-const class_validator_1 = require("class-validator");
-class UpdateCliDto {
-    name;
-    version;
-}
-exports.UpdateCliDto = UpdateCliDto;
-__decorate([
-    (0, swagger_1.ApiProperty)({ description: 'CLI tool name to update' }),
-    (0, class_validator_1.IsString)(),
-    (0, class_validator_1.IsNotEmpty)(),
-    __metadata("design:type", String)
-], UpdateCliDto.prototype, "name", void 0);
-__decorate([
-    (0, swagger_1.ApiPropertyOptional)({ description: 'Version to install (default: latest)', example: '1.0.0' }),
-    (0, class_validator_1.IsString)(),
-    (0, class_validator_1.IsOptional)(),
-    __metadata("design:type", String)
-], UpdateCliDto.prototype, "version", void 0);