@microwiseai/snapshot 0.3.5 → 0.3.26

package/dist/commands/install.js

@@ -1,16 +1,310 @@
 import chalk from 'chalk';
 import { execSync } from 'child_process';
+import { writeFileSync, existsSync, readFileSync, unlinkSync } from 'fs';
+import { homedir, platform, arch } from 'os';
+import { join } from 'path';
 import { fetchSnapshotFromRepo, snapshotNameToRepoName } from '../lib/gitlab.js';
 import { saveCurrentSnapshot } from '../lib/snapshot.js';
-import { getGitlabToken } from '../lib/config.js';
-async function installSnapshot(snapshot, depth = 0) {
+import { getLicenseKey, REGISTRY_PROXY_URL, VENDOR_NAME, STORE_URL, PACKAGE_NAME, getIstCredentials, LICENSE_API_URL } from '../lib/config.js';
+import { resolveSnapshotDependencies, detectPackageType } from '../lib/package-resolver.js';
+import { resolveDepsFromLicenseAPI } from '../lib/transitive-resolver.js';
+import { installSkitPackage } from '../lib/skit-adapter.js';
+import { createLicenseClient, markLicenseChecked } from '@microwiseai/license';
+// CLI version (from package.json)
+const CLI_VERSION = '0.3.25';
+/**
+ * Send install telemetry to license-api (fire and forget)
+ */
+async function sendInstallTelemetry(data) {
+    try {
+        const telemetry = {
+            event: 'install',
+            ...data,
+            timestamp: new Date().toISOString(),
+        };
+        // Fire and forget - don't block on response
+        fetch(`${LICENSE_API_URL}/telemetry`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                machineId: data.userId || 'anonymous',
+                instanceName: data.package,
+                vendorName: VENDOR_NAME,
+                packageName: data.package,
+                packageVersion: data.version,
+                sdkVersion: data.cliVersion,
+                licenseStatus: data.success ? 'valid' : 'invalid',
+                licenseType: 'beta',
+                productId: 'snapshot-cli',
+                platform: data.platform,
+                nodeVersion: process.version,
+                // Custom fields in metadata
+                metadata: JSON.stringify(telemetry),
+            }),
+        }).catch(() => {
+            // Silently ignore telemetry errors
+        });
+    }
+    catch {
+        // Silently ignore telemetry errors
+    }
+}
+// Default installers for backward compatibility
+const DEFAULT_INSTALLERS = {
+    'glpkg': {
+        command: 'glpkg install {pkg}',
+        check: 'glpkg --version',
+        hint: 'npm install -g @glpkg/cli',
+    },
+    // Legacy alias for backward compatibility
+    'gitlab-install': {
+        command: 'glpkg install {pkg}',
+        check: 'glpkg --version',
+        hint: 'npm install -g @glpkg/cli (gitlab-install is deprecated, use glpkg)',
+    },
+    'skit': {
+        command: 'skit install {pkg}',
+        check: 'skit --version',
+        hint: 'npm install -g @ist/skit',
+    },
+    'npm-proxy': {
+        command: 'npm install -g {pkg}',
+        check: 'npm --version',
+        hint: 'npm is required',
+    },
+};
+/**
+ * Configure .npmrc for registry-proxy with session token
+ */
+function configureNpmrcForProxy(scopes, licenseKey) {
+    const npmrcPath = join(homedir(), '.npmrc');
+    let originalContent = null;
+    // Backup existing .npmrc
+    if (existsSync(npmrcPath)) {
+        originalContent = readFileSync(npmrcPath, 'utf-8');
+    }
+    // Build new .npmrc content
+    const proxyHost = REGISTRY_PROXY_URL.replace('https://', '');
+    const lines = [];
+    // Keep existing content that's not related to our scopes
+    if (originalContent) {
+        const existingLines = originalContent.split('\n');
+        for (const line of existingLines) {
+            // Skip lines related to our scopes or proxy
+            const isOurScope = scopes.some(s => line.includes(`${s}:registry`));
+            const isProxyAuth = line.includes(proxyHost);
+            if (!isOurScope && !isProxyAuth && line.trim()) {
+                lines.push(line);
+            }
+        }
+    }
+    // Add proxy registry config for each scope
+    for (const scope of scopes) {
+        lines.push(`${scope}:registry=${REGISTRY_PROXY_URL}/`);
+    }
+    // Add auth token for proxy
+    lines.push(`//${proxyHost}/:_authToken=${licenseKey}`);
+    writeFileSync(npmrcPath, lines.join('\n') + '\n');
+    return { path: npmrcPath, content: originalContent };
+}
+/**
+ * Restore original .npmrc
+ */
+function restoreNpmrc(backup) {
+    if (backup.content === null) {
+        // Original didn't exist, remove it
+        if (existsSync(backup.path)) {
+            unlinkSync(backup.path);
+        }
+    }
+    else {
+        // Restore original content
+        writeFileSync(backup.path, backup.content);
+    }
+}
+/**
+ * Configure .npmrc for registry-proxy WITHOUT auth token (anonymous access)
+ */
+function configureNpmrcForProxyAnonymous(scopes) {
+    const npmrcPath = join(homedir(), '.npmrc');
+    let originalContent = null;
+    // Backup existing .npmrc
+    if (existsSync(npmrcPath)) {
+        originalContent = readFileSync(npmrcPath, 'utf-8');
+    }
+    // Build new .npmrc content
+    const proxyHost = REGISTRY_PROXY_URL.replace('https://', '');
+    const lines = [];
+    // Keep existing content that's not related to our scopes
+    if (originalContent) {
+        const existingLines = originalContent.split('\n');
+        for (const line of existingLines) {
+            // Skip lines related to our scopes or proxy
+            const isOurScope = scopes.some(s => line.includes(`${s}:registry`));
+            const isProxyAuth = line.includes(proxyHost);
+            if (!isOurScope && !isProxyAuth && line.trim()) {
+                lines.push(line);
+            }
+        }
+    }
+    // Add proxy registry config for each scope (NO auth token)
+    for (const scope of scopes) {
+        lines.push(`${scope}:registry=${REGISTRY_PROXY_URL}/`);
+    }
+    writeFileSync(npmrcPath, lines.join('\n') + '\n');
+    return { path: npmrcPath, content: originalContent };
+}
+/**
+ * Extract scopes from packages
+ */
+function extractScopes(packages) {
+    const scopes = new Set();
+    for (const name of Object.keys(packages)) {
+        if (name.startsWith('@')) {
+            const scope = name.split('/')[0];
+            scopes.add(scope);
+        }
+    }
+    return Array.from(scopes);
+}
+function commandExists(cmd) {
+    try {
+        const checkCmd = process.platform === 'win32'
+            ? `where ${cmd.split(' ')[0]}`
+            : `which ${cmd.split(' ')[0]}`;
+        execSync(checkCmd, { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function runCommand(command) {
+    try {
+        execSync(command, { stdio: 'pipe', encoding: 'utf-8' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * PackageType을 installer 이름으로 변환
+ */
+function packageTypeToInstaller(type, useProxy) {
+    switch (type) {
+        case 'skit':
+            return 'skit';
+        case 'npm':
+            return useProxy ? 'npm-proxy' : 'glpkg';
+        case 'generic':
+        default:
+            return 'glpkg';
+    }
+}
+/**
+ * Skit 패키지 설치 (lib 우선, CLI fallback)
+ * @ist/skit lib가 있으면 직접 호출, 없으면 CLI 사용
+ */
+async function installSkitPackages(packages, snapshotName, indent) {
+    const result = { installed: [], failed: [] };
+    const packageEntries = Object.entries(packages);
+    if (packageEntries.length === 0) {
+        return result;
+    }
+    const total = packageEntries.length;
+    console.log('');
+    console.log(chalk.yellow(`${indent}=== ${snapshotName}: ${total} skits ===`));
+    // Install packages using skit-adapter
+    for (let i = 0; i < packageEntries.length; i++) {
+        const [name, version] = packageEntries[i];
+        const pkgSpec = `${name}@${version}`;
+        const progress = `[${i + 1}/${total}]`;
+        process.stdout.write(`${indent}${chalk.blue(progress)} ${pkgSpec}...`);
+        try {
+            const installResult = await installSkitPackage(name, version);
+            if (installResult.success) {
+                console.log(chalk.green(' ✓'));
+                result.installed.push(pkgSpec);
+            }
+            else {
+                console.log(chalk.red(' ✗'));
+                if (installResult.error) {
+                    console.log(chalk.gray(`${indent}  ${installResult.error}`));
+                }
+                result.failed.push(pkgSpec);
+            }
+        }
+        catch (error) {
+            console.log(chalk.red(' ✗'));
+            const errMsg = error instanceof Error ? error.message : String(error);
+            console.log(chalk.gray(`${indent}  ${errMsg}`));
+            result.failed.push(pkgSpec);
+        }
+    }
+    return result;
+}
+/**
+ * 타입별 패키지 설치 (non-skit)
+ */
+async function installPackagesByType(packages, installerName, installers, snapshotName, indent, typeLabel) {
+    const result = { installed: [], failed: [] };
+    const packageEntries = Object.entries(packages);
+    if (packageEntries.length === 0) {
+        return result;
+    }
+    // Skit packages use dedicated function
+    if (installerName === 'skit') {
+        return installSkitPackages(packages, snapshotName, indent);
+    }
+    const installerConfig = installers[installerName] || DEFAULT_INSTALLERS[installerName];
+    if (!installerConfig) {
+        console.log(chalk.red(`${indent}Unknown installer: ${installerName}`));
+        result.failed.push(...packageEntries.map(([n, v]) => `${n}@${v}`));
+        return result;
+    }
+    const total = packageEntries.length;
+    console.log('');
+    console.log(chalk.yellow(`${indent}=== ${snapshotName}: ${total} ${typeLabel} (${installerName}) ===`));
+    // Check if installer exists
+    const cmdName = installerConfig.check.split(' ')[0];
+    if (!commandExists(cmdName)) {
+        console.log(chalk.red(`${indent}${installerName} not found.`));
+        console.log(chalk.yellow(`${indent}Install: ${installerConfig.hint}`));
+        result.failed.push(...packageEntries.map(([n, v]) => `${n}@${v}`));
+        return result;
+    }
+    // Install packages
+    for (let i = 0; i < packageEntries.length; i++) {
+        const [name, version] = packageEntries[i];
+        const pkgSpec = `${name}@${version}`;
+        const progress = `[${i + 1}/${total}]`;
+        const command = installerConfig.command.replace('{pkg}', pkgSpec);
+        process.stdout.write(`${indent}${chalk.blue(progress)} ${pkgSpec}...`);
+        if (runCommand(command)) {
+            console.log(chalk.green(' ✓'));
+            result.installed.push(pkgSpec);
+        }
+        else {
+            console.log(chalk.red(' ✗'));
+            result.failed.push(pkgSpec);
+        }
+    }
+    return result;
+}
+export async function installSnapshot(snapshot, depth = 0, parentInstallers = {}, options = {}) {
     const indent = '  '.repeat(depth);
     const result = {
-        packages: [],
-        skits: [],
-        failedPackages: [],
-        failedSkits: [],
+        installed: [],
+        failed: [],
     };
+    // Merge installers: snapshot + parent (parent takes precedence for overrides like npm-proxy)
+    let installers = { ...DEFAULT_INSTALLERS };
+    if (snapshot.installers) {
+        installers = { ...installers, ...snapshot.installers };
+    }
+    // Parent installers take precedence (for effectiveInstallers override)
+    installers = { ...installers, ...parentInstallers };
     // Handle extends - install base snapshot first
     if (snapshot.extends) {
         console.log('');
@@ -18,11 +312,11 @@ async function installSnapshot(snapshot, depth = 0) {
         try {
             const baseSnapshot = await fetchSnapshotFromRepo(snapshot.extends);
             console.log(chalk.gray(`${indent}  Installing base snapshot...`));
-            const baseResult = await installSnapshot(baseSnapshot, depth + 1);
-            result.packages.push(...baseResult.packages);
-            result.skits.push(...baseResult.skits);
-            result.failedPackages.push(...baseResult.failedPackages);
-            result.failedSkits.push(...baseResult.failedSkits);
+            const baseResult = await installSnapshot(baseSnapshot, depth + 1, installers, options);
+            result.installed.push(...baseResult.result.installed);
+            result.failed.push(...baseResult.result.failed);
+            // Update installers with any from base
+            installers = { ...installers, ...baseResult.installers };
         }
         catch (error) {
             const errMsg = error instanceof Error ? error.message : String(error);
@@ -44,71 +338,123 @@ async function installSnapshot(snapshot, depth = 0) {
             }
         }
     }
-    const packages = snapshot.packages || {};
-    const skits = snapshot.skits || {};
-    const packageEntries = Object.entries(packages);
-    const skitEntries = Object.entries(skits);
-    // Install npm packages
-    if (packageEntries.length > 0) {
-        const total = packageEntries.length;
-        console.log('');
-        console.log(chalk.yellow(`${indent}=== ${snapshot.name}: ${total} packages ===`));
-        for (let i = 0; i < packageEntries.length; i++) {
-            const [name, version] = packageEntries[i];
-            const pkgSpec = `${name}@${version}`;
-            const progress = `[${i + 1}/${total}]`;
-            process.stdout.write(`${indent}${chalk.blue(progress)} ${pkgSpec}...`);
-            try {
-                execSync(`gitlab-install add -g ${pkgSpec}`, {
-                    stdio: 'pipe',
-                    encoding: 'utf-8',
-                });
-                console.log(chalk.green(' ✓'));
-                result.packages.push(pkgSpec);
+    // ============================================================
+    // Auto-detect mode: 패키지 타입 자동 판별
+    // ============================================================
+    if (options.autoDetect && !snapshot.install) {
+        console.log(chalk.gray(`${indent}  Auto-detecting package types...`));
+        const resolved = await resolveSnapshotDependencies(snapshot, { skipRegistry: true });
+        // skit 패키지 설치 (skit-adapter 사용: lib 우선, CLI fallback)
+        if (Object.keys(resolved.skit).length > 0) {
+            const skitResult = await installSkitPackages(resolved.skit, snapshot.name, indent);
+            result.installed.push(...skitResult.installed);
+            result.failed.push(...skitResult.failed);
+        }
+        // npm 패키지 설치 (proxy 사용 시 npm-proxy, 아니면 glpkg)
+        if (Object.keys(resolved.npm).length > 0) {
+            const npmInstaller = options.useProxy ? 'npm-proxy' : 'glpkg';
+            const npmResult = await installPackagesByType(resolved.npm, npmInstaller, installers, snapshot.name, indent, 'npm packages');
+            result.installed.push(...npmResult.installed);
+            result.failed.push(...npmResult.failed);
+        }
+        // generic 패키지 설치 (glpkg)
+        if (Object.keys(resolved.generic).length > 0) {
+            const genericInstaller = options.useProxy ? 'npm-proxy' : 'glpkg';
+            const genericResult = await installPackagesByType(resolved.generic, genericInstaller, installers, snapshot.name, indent, 'packages');
+            result.installed.push(...genericResult.installed);
+            result.failed.push(...genericResult.failed);
+        }
+        return { result, installers };
+    }
+    // ============================================================
+    // Legacy mode: 기존 방식 (하위호환)
+    // ============================================================
+    // New structure: install block
+    if (snapshot.install) {
+        for (const [installerName, packages] of Object.entries(snapshot.install)) {
+            const packageEntries = Object.entries(packages);
+            if (packageEntries.length === 0)
+                continue;
+            // Skit packages: use skit-adapter (lib 우선, CLI fallback)
+            if (installerName === 'skit') {
+                const skitResult = await installSkitPackages(packages, snapshot.name, indent);
+                result.installed.push(...skitResult.installed);
+                result.failed.push(...skitResult.failed);
+                continue;
             }
-            catch {
-                console.log(chalk.red(' ✗'));
-                result.failedPackages.push(pkgSpec);
+            const installerConfig = installers[installerName] || DEFAULT_INSTALLERS[installerName];
+            if (!installerConfig) {
+                console.log(chalk.red(`${indent}Unknown installer: ${installerName}`));
+                result.failed.push(...packageEntries.map(([n, v]) => `${n}@${v}`));
+                continue;
+            }
+            const total = packageEntries.length;
+            console.log('');
+            console.log(chalk.yellow(`${indent}=== ${snapshot.name}: ${total} packages (${installerName}) ===`));
+            // Check if installer exists
+            const cmdName = installerConfig.check.split(' ')[0];
+            if (!commandExists(cmdName)) {
+                console.log(chalk.red(`${indent}${installerName} not found.`));
+                console.log(chalk.yellow(`${indent}Install: ${installerConfig.hint}`));
+                result.failed.push(...packageEntries.map(([n, v]) => `${n}@${v}`));
+                continue;
+            }
+            // Install packages
+            for (let i = 0; i < packageEntries.length; i++) {
+                const [name, version] = packageEntries[i];
+                const pkgSpec = `${name}@${version}`;
+                const progress = `[${i + 1}/${total}]`;
+                const command = installerConfig.command.replace('{pkg}', pkgSpec);
+                process.stdout.write(`${indent}${chalk.blue(progress)} ${pkgSpec}...`);
+                if (runCommand(command)) {
+                    console.log(chalk.green(' ✓'));
+                    result.installed.push(pkgSpec);
+                }
+                else {
+                    console.log(chalk.red(' ✗'));
+                    result.failed.push(pkgSpec);
+                }
             }
         }
     }
-    // Install skits
-    if (skitEntries.length > 0) {
-        const total = skitEntries.length;
+    // Legacy: packages (use glpkg)
+    if (snapshot.packages && Object.keys(snapshot.packages).length > 0) {
+        const packageEntries = Object.entries(snapshot.packages);
+        const total = packageEntries.length;
+        const installerConfig = installers['glpkg'] || DEFAULT_INSTALLERS['glpkg'];
         console.log('');
-        console.log(chalk.yellow(`${indent}=== ${snapshot.name}: ${total} skits ===`));
-        // Check if skit command exists
-        let skitAvailable = true;
-        try {
-            execSync('which skit', { stdio: 'pipe' });
-        }
-        catch {
-            console.log(chalk.red(`${indent}skit command not found.`));
-            skitAvailable = false;
-            result.failedSkits.push(...skitEntries.map(([n, v]) => `${n}@${v}`));
+        console.log(chalk.yellow(`${indent}=== ${snapshot.name}: ${total} packages ===`));
+        const cmdName = installerConfig.check.split(' ')[0];
+        if (!commandExists(cmdName)) {
+            console.log(chalk.red(`${indent}glpkg not found.`));
+            console.log(chalk.yellow(`${indent}Install: ${installerConfig.hint}`));
+            result.failed.push(...packageEntries.map(([n, v]) => `${n}@${v}`));
         }
-        if (skitAvailable) {
-            for (let i = 0; i < skitEntries.length; i++) {
-                const [name, version] = skitEntries[i];
-                const skitSpec = `${name}@${version}`;
+        else {
+            for (let i = 0; i < packageEntries.length; i++) {
+                const [name, version] = packageEntries[i];
+                const pkgSpec = `${name}@${version}`;
                 const progress = `[${i + 1}/${total}]`;
-                process.stdout.write(`${indent}${chalk.blue(progress)} ${skitSpec}...`);
-                try {
-                    execSync(`skit add ${skitSpec}`, {
-                        stdio: 'pipe',
-                        encoding: 'utf-8',
-                    });
+                const command = installerConfig.command.replace('{pkg}', pkgSpec);
+                process.stdout.write(`${indent}${chalk.blue(progress)} ${pkgSpec}...`);
+                if (runCommand(command)) {
                     console.log(chalk.green(' ✓'));
-                    result.skits.push(skitSpec);
+                    result.installed.push(pkgSpec);
                 }
-                catch {
+                else {
                     console.log(chalk.red(' ✗'));
-                    result.failedSkits.push(skitSpec);
+                    result.failed.push(pkgSpec);
                 }
             }
         }
     }
-    return result;
+    // Legacy: skits (use skit-adapter: lib 우선, CLI fallback)
+    if (snapshot.skits && Object.keys(snapshot.skits).length > 0) {
+        const skitResult = await installSkitPackages(snapshot.skits, snapshot.name, indent);
+        result.installed.push(...skitResult.installed);
+        result.failed.push(...skitResult.failed);
+    }
+    return { result, installers };
 }
 export async function installCommand(name) {
     console.log(chalk.blue.bold(`
@@ -116,6 +462,34 @@ export async function installCommand(name) {
 ║                    Snapshot Installer                        ║
 ╚══════════════════════════════════════════════════════════════╝
 `));
+    // ========== IST Login Check ==========
+    const istCredentials = getIstCredentials();
+    if (!istCredentials?.userId) {
+        console.log(chalk.red('⛔ IST login required'));
+        console.log(chalk.gray('   Run: ist auth login'));
+        process.exit(1);
+    }
+    console.log(chalk.green('✓') + ' IST login verified');
+    // ======================================
+    // ========== License Check ==========
+    const apiUrl = process.env.LICENSE_API_URL || 'https://license-api.sisung-kim1.workers.dev/api';
+    const license = createLicenseClient({
+        vendorName: VENDOR_NAME,
+        apiUrl,
+        cliCommand: 'snapshot license',
+        storeUrl: STORE_URL,
+    });
+    const licenseResult = await license.checkLicense();
+    if (licenseResult.valid) {
+        markLicenseChecked(PACKAGE_NAME);
+        console.log(chalk.green('✓') + ' License verified');
+    }
+    else {
+        // License invalid - try anonymous access (public packages will work via registry-proxy)
+        console.log(chalk.yellow('⚠') + ' No license - trying anonymous access...');
+        console.log(chalk.gray('  (Public packages will install without license)'));
+    }
+    // ====================================
     // Validate name
     let repoName;
     try {
@@ -132,27 +506,17 @@ export async function installCommand(name) {
     }
     console.log(chalk.gray(`Snapshot: ${name}`));
     console.log(chalk.gray(`Repo: ${repoName}`));
-    // Check GitLab token
-    const token = getGitlabToken();
-    if (!token) {
-        console.log(chalk.red('Error: GitLab token not found.'));
-        console.log(chalk.yellow('Run: gitlab-config save <token>'));
-        process.exit(1);
-    }
-    console.log(chalk.green('✓') + ' GitLab token found');
-    // Check gitlab-install (cross-platform)
-    try {
-        const whichCmd = process.platform === 'win32' ? 'where gitlab-install' : 'which gitlab-install';
-        execSync(whichCmd, { stdio: 'pipe' });
+    // Check auth: license key for registry-proxy
+    const licenseKey = getLicenseKey();
+    const useProxy = true; // Always use registry-proxy
+    if (licenseKey) {
+        console.log(chalk.green('✓') + ' Using registry-proxy with license key');
     }
-    catch {
-        console.log(chalk.red('Error: gitlab-install not found.'));
-        console.log(chalk.yellow('Install: npm install -g @glpkg/installer'));
-        process.exit(1);
+    else {
+        console.log(chalk.yellow('⚠') + ' No license key - trying anonymous access');
     }
-    console.log(chalk.green('✓') + ' gitlab-install available');
     // Fetch snapshot
-    console.log(chalk.gray('Fetching snapshot from GitLab...'));
+    console.log(chalk.gray('Fetching snapshot...'));
     let snapshot;
     try {
         snapshot = await fetchSnapshotFromRepo(name);
@@ -167,44 +531,203 @@ export async function installCommand(name) {
     if (snapshot.description) {
         console.log(chalk.gray(`  ${snapshot.description}`));
     }
+    // ========== Resolve Dependencies via Registry Proxy API ==========
+    let apiResolvedDeps = null;
+    if (licenseKey && snapshot.registry && snapshot.install) {
+        // Extract scopes and first groupId from snapshot.registry
+        const scopes = [];
+        let groupId = null;
+        for (const [scope, config] of Object.entries(snapshot.registry)) {
+            const normalizedScope = scope.startsWith('@') ? scope : `@${scope}`;
+            scopes.push(normalizedScope);
+            if (config.group && !groupId) {
+                groupId = config.group;
+            }
+        }
+        // Extract packages from snapshot.install (all installers)
+        const packages = [];
+        for (const pkgs of Object.values(snapshot.install)) {
+            for (const [name, version] of Object.entries(pkgs)) {
+                packages.push(`${name}@${version}`);
+            }
+        }
+        if (packages.length > 0 && groupId && scopes.length > 0) {
+            console.log(chalk.gray('Resolving dependencies via Registry Proxy API...'));
+            try {
+                apiResolvedDeps = await resolveDepsFromLicenseAPI({
+                    packages,
+                    groupId,
+                    scopes,
+                    includePeer: true,
+                });
+                const depCount = Object.keys(apiResolvedDeps.dependencies).length;
+                const peerCount = Object.keys(apiResolvedDeps.peerDependencies || {}).length;
+                console.log(chalk.green('✓') + ` Resolved ${depCount} dependencies, ${peerCount} peer dependencies`);
+            }
+            catch (error) {
+                const errMsg = error instanceof Error ? error.message : String(error);
+                console.log(chalk.yellow('⚠') + ` Registry Proxy API resolve failed: ${errMsg}`);
+                console.log(chalk.gray('  Falling back to local dependency resolution...'));
+            }
+        }
+    }
+    // ================================================================
+    // ========== Snapshot Access Check ==========
+    if (snapshot.access && typeof snapshot.access === 'object' && snapshot.access.type === 'licensed') {
+        const productId = snapshot.access.productId;
+        const accessResult = await license.checkLicense({ productId });
+        if (!accessResult.valid) {
+            console.log('');
+            console.log(chalk.red('⛔ This snapshot requires a license'));
+            console.log(chalk.gray(`   Product: ${productId}`));
+            console.log(chalk.gray(`   Activate: snapshot license activate <KEY>`));
+            process.exit(1);
+        }
+        console.log(chalk.green('✓') + ` License verified for ${productId}`);
+    }
+    // access가 없거나 'public'이면 그냥 통과
+    // ============================================
+    // Collect all packages to determine scopes
+    const allPackages = {
+        ...(snapshot.packages || {}),
+    };
+    if (snapshot.install) {
+        for (const pkgs of Object.values(snapshot.install)) {
+            Object.assign(allPackages, pkgs);
+        }
+    }
+    // Configure .npmrc for proxy (with or without auth token)
+    let npmrcBackup = null;
+    if (useProxy) {
+        const scopes = extractScopes(allPackages);
+        if (scopes.length > 0) {
+            if (licenseKey) {
+                console.log(chalk.gray(`Configuring registry-proxy for scopes: ${scopes.join(', ')}`));
+                npmrcBackup = configureNpmrcForProxy(scopes, licenseKey);
+            }
+            else {
+                // Anonymous mode - configure proxy without auth token
+                console.log(chalk.gray(`Configuring registry-proxy (anonymous) for scopes: ${scopes.join(', ')}`));
+                npmrcBackup = configureNpmrcForProxyAnonymous(scopes);
+            }
+        }
+    }
+    // Determine which installers to use
+    const effectiveInstallers = { ...DEFAULT_INSTALLERS };
+    if (useProxy) {
+        // When using proxy, override glpkg with npm-proxy
+        effectiveInstallers['glpkg'] = DEFAULT_INSTALLERS['npm-proxy'];
+        effectiveInstallers['gitlab-install'] = DEFAULT_INSTALLERS['npm-proxy'];
+    }
     // Install (handles extends recursively)
-    const result = await installSnapshot(snapshot, 0);
+    let installError = null;
+    let result = { installed: [], failed: [] };
+    try {
+        // API 결과가 있으면 snapshot.install 구성
+        let effectiveSnapshot = snapshot;
+        if (apiResolvedDeps) {
+            // API 결과를 타입별로 분류
+            const allDeps = {
+                ...apiResolvedDeps.dependencies,
+                ...(apiResolvedDeps.peerDependencies || {}),
+            };
+            const classified = {
+                skit: {},
+                npm: {},
+                generic: {},
+            };
+            // 병렬로 타입 판별
+            const entries = Object.entries(allDeps);
+            const types = await Promise.all(entries.map(([name]) => detectPackageType(name, { skipRegistry: true })));
+            for (let i = 0; i < entries.length; i++) {
+                const [name, version] = entries[i];
+                const type = types[i];
+                classified[type][name] = version;
+            }
+            // snapshot.install 구성
+            const newInstall = {};
+            if (Object.keys(classified.skit).length > 0) {
+                newInstall['skit'] = classified.skit;
+            }
+            if (Object.keys(classified.npm).length > 0) {
+                newInstall[useProxy ? 'npm-proxy' : 'glpkg'] = classified.npm;
+            }
+            if (Object.keys(classified.generic).length > 0) {
+                newInstall[useProxy ? 'npm-proxy' : 'glpkg'] = {
+                    ...(newInstall[useProxy ? 'npm-proxy' : 'glpkg'] || {}),
+                    ...classified.generic,
+                };
+            }
+            // 기존 snapshot 복사 후 install 오버라이드
+            effectiveSnapshot = {
+                ...snapshot,
+                install: newInstall,
+            };
+            console.log(chalk.gray(`  skit: ${Object.keys(classified.skit).length}, npm: ${Object.keys(classified.npm).length}, generic: ${Object.keys(classified.generic).length}`));
+        }
+        // Auto-detect 모드: snapshot.install이 없으면 자동 판별 (API 실패 시 fallback)
+        const autoDetect = !effectiveSnapshot.install;
+        const installResult = await installSnapshot(effectiveSnapshot, 0, effectiveInstallers, {
+            useProxy,
+            autoDetect,
+        });
+        result = installResult.result;
+    }
+    catch (err) {
+        installError = err instanceof Error ? err : new Error(String(err));
+    }
+    finally {
+        // Restore .npmrc
+        if (npmrcBackup) {
+            restoreNpmrc(npmrcBackup);
+            console.log(chalk.gray('Restored .npmrc'));
+        }
+    }
+    if (installError) {
+        console.log(chalk.red(`Error during installation: ${installError.message}`));
+        process.exit(1);
+    }
     // Summary
     console.log('');
     console.log(chalk.yellow('═══════════════════════════════════'));
     console.log(chalk.yellow('           Final Summary           '));
     console.log(chalk.yellow('═══════════════════════════════════'));
-    const totalPkgs = result.packages.length + result.failedPackages.length;
-    const totalSkits = result.skits.length + result.failedSkits.length;
-    if (totalPkgs > 0) {
-        console.log(`Packages: ${chalk.green(result.packages.length)}/${totalPkgs}`);
-    }
-    if (totalSkits > 0) {
-        console.log(`Skits: ${chalk.green(result.skits.length)}/${totalSkits}`);
-    }
-    if (result.failedPackages.length > 0 || result.failedSkits.length > 0) {
+    const total = result.installed.length + result.failed.length;
+    console.log(`Installed: ${chalk.green(result.installed.length)}/${total}`);
+    if (result.failed.length > 0) {
         console.log('');
         console.log(chalk.red('Failed:'));
-        for (const pkg of result.failedPackages) {
+        for (const pkg of result.failed) {
             console.log(chalk.red(`  ✗ ${pkg}`));
         }
-        for (const skit of result.failedSkits) {
-            console.log(chalk.red(`  ✗ ${skit}`));
-        }
     }
     // Save
-    if (result.packages.length > 0 || result.skits.length > 0) {
+    if (result.installed.length > 0) {
         saveCurrentSnapshot({
             name: snapshot.name,
             version: snapshot.version,
             installedAt: new Date().toISOString(),
-            packages: result.packages,
-            skits: result.skits,
+            packages: result.installed,
         });
         console.log('');
         console.log(chalk.green('✓') + ' Snapshot info saved');
     }
-    if (result.failedPackages.length > 0 || result.failedSkits.length > 0) {
+    // Send telemetry (fire and forget)
+    sendInstallTelemetry({
+        package: snapshot.name,
+        version: snapshot.version,
+        success: result.failed.length === 0,
+        installedCount: result.installed.length,
+        failedCount: result.failed.length,
+        error: result.failed.length > 0 ? `Failed: ${result.failed.join(', ')}` : undefined,
+        userId: istCredentials?.userId,
+        userEmail: istCredentials?.email,
+        licenseKey: licenseKey ? licenseKey.substring(0, 9) : undefined,
+        platform: platform(),
+        arch: arch(),
+        cliVersion: CLI_VERSION,
+    });
+    if (result.failed.length > 0) {
         process.exit(1);
     }
 }