@thinkrun/cli 0.1.27

package/dist/src/commands/install.js

@@ -0,0 +1,975 @@
+/**
+ * `thinkrun install` — downloads, verifies, and registers the native host binary.
+ *
+ * Downloads, verifies, and registers the native host binary with better UX:
+ * progress bar, coloured output, --force and --check flags.
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { statSync, createWriteStream, chmodSync, existsSync, mkdirSync, renameSync, unlinkSync, readFileSync, } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+import { pipeline } from 'stream/promises';
+import { get as httpGet } from 'http';
+import { get as httpsGet } from 'https';
+import { createHash } from 'crypto';
+import { spawnSync } from 'child_process';
+import { config } from '../config/store.js';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function resolvePackageJsonPath() {
+    const candidates = [
+        // Bun source execution: packages/cli/src/commands -> packages/cli/package.json
+        join(__dirname, '..', '..', 'package.json'),
+        // Built package: packages/cli/dist/src/commands -> packages/cli/package.json
+        join(__dirname, '..', '..', '..', 'package.json'),
+    ];
+    const found = candidates.find((candidate) => existsSync(candidate));
+    if (found)
+        return found;
+    return candidates[0];
+}
+const PKG_JSON_PATH = resolvePackageJsonPath();
+const REPO = 'dundas/thinkbrowse';
+// Keep the installed native-host binary under the legacy directory during the
+// internal pass. The host ID, binary name, release assets, and local install
+// path remain frozen at ~/.thinkbrowse/bin even though the public CLI surface
+// is now `thinkrun`.
+const INSTALL_DIR = join(homedir(), '.thinkbrowse', 'bin');
+const BINARY_NAME = 'thinkbrowse-host';
+export const DEFAULT_EXTENSION_ID = 'cjjiphmogljacdphamjhfinpmejlhfbn';
+const EXTENSION_ID_ENV = 'THINKRUN_EXTENSION_ID';
+const LEGACY_EXTENSION_ID_ENV = 'THINKBROWSE_EXTENSION_ID';
+const MAX_REDIRECTS = 10;
+const DOWNLOAD_TIMEOUT_MS = 60_000;
+const DOWNLOAD_BASE_URL_OVERRIDE_ENV = 'THINKRUN_INSTALL_BASE_URL';
+const LEGACY_INSTALL_BASE_URL_OVERRIDE_ENV = 'THINKBROWSE_INSTALL_BASE_URL';
+const LEGACY_DOWNLOAD_BASE_URL_OVERRIDE_ENV = 'THINKBROWSE_NATIVE_HOST_BASE_URL';
+const ENABLE_TEST_DOWNLOAD_BASE_URL_ENV = 'THINKRUN_ENABLE_TEST_NATIVE_HOST_BASE_URL';
+const LEGACY_ENABLE_TEST_DOWNLOAD_BASE_URL_ENV = 'THINKBROWSE_ENABLE_TEST_NATIVE_HOST_BASE_URL';
+const LOOPBACK_DOWNLOAD_OVERRIDE_ENV = 'THINKRUN_INSTALL_ALLOW_LOOPBACK_HTTP';
+const LEGACY_LOOPBACK_DOWNLOAD_OVERRIDE_ENV = 'THINKBROWSE_INSTALL_ALLOW_LOOPBACK_HTTP';
+const SAFE_PROFILE_MARKER = /^[A-Za-z0-9 ._-]+$/;
+function markerPath(baseDir, marker) {
+    const separator = baseDir.includes('\\') ? '\\' : '/';
+    return `${baseDir}${separator}${marker}`;
+}
+export function shouldClearPackagedDefaultPreference(source) {
+    return source !== 'registered';
+}
+export function isValidExtensionId(extensionId) {
+    return typeof extensionId === 'string' && /^[a-p]{32}$/.test(extensionId);
+}
+function isLoopbackHostname(hostname) {
+    return hostname === '127.0.0.1' || hostname === 'localhost' || hostname === '::1' || hostname === '[::1]';
+}
+function isLegacyLoopbackDownloadOverrideEnabled() {
+    return process.env[LEGACY_ENABLE_TEST_DOWNLOAD_BASE_URL_ENV] === '1'
+        && typeof process.env[LEGACY_DOWNLOAD_BASE_URL_OVERRIDE_ENV] === 'string'
+        && process.env[LEGACY_DOWNLOAD_BASE_URL_OVERRIDE_ENV].trim().length > 0;
+}
+function isLoopbackDownloadOverrideEnabled() {
+    return process.env[ENABLE_TEST_DOWNLOAD_BASE_URL_ENV] === '1'
+        && (typeof process.env[DOWNLOAD_BASE_URL_OVERRIDE_ENV] === 'string'
+            || typeof process.env[LEGACY_INSTALL_BASE_URL_OVERRIDE_ENV] === 'string');
+}
+function isLoopbackHttpDownloadAllowed() {
+    return process.env[LOOPBACK_DOWNLOAD_OVERRIDE_ENV] === '1'
+        || process.env[LEGACY_LOOPBACK_DOWNLOAD_OVERRIDE_ENV] === '1'
+        || isLoopbackDownloadOverrideEnabled()
+        || isLegacyLoopbackDownloadOverrideEnabled();
+}
+export function resolveExtensionIdFromSources(opts) {
+    if (isValidExtensionId(opts.extensionId)) {
+        return { extensionId: opts.extensionId, source: 'flag' };
+    }
+    if (isValidExtensionId(opts.envExtensionId)) {
+        return { extensionId: opts.envExtensionId, source: 'env' };
+    }
+    if (isValidExtensionId(opts.configuredExtensionId)) {
+        return { extensionId: opts.configuredExtensionId, source: 'config' };
+    }
+    return { extensionId: DEFAULT_EXTENSION_ID, source: 'default' };
+}
+export function resolveExtensionId(extensionId) {
+    return resolveExtensionIdFromSources({
+        extensionId,
+        envExtensionId: process.env[EXTENSION_ID_ENV] || process.env[LEGACY_EXTENSION_ID_ENV],
+        configuredExtensionId: config.get('extensionId'),
+    });
+}
+export function resolveRegistrationExtensionIdFromSources(opts) {
+    const resolved = resolveExtensionIdFromSources(opts);
+    if (resolved.source !== 'default') {
+        return resolved;
+    }
+    if (opts.preferPackagedDefaultExtensionId) {
+        return resolved;
+    }
+    const registeredExtensionId = isValidExtensionId(opts.registeredExtensionId)
+        ? opts.registeredExtensionId
+        : undefined;
+    const distinctManifestExtensionIds = Array.isArray(opts.manifestExtensionIds)
+        ? Array.from(new Set(opts.manifestExtensionIds.filter((value) => isValidExtensionId(value))))
+        : [];
+    if (opts.manifestParseStatus === 'parsed') {
+        if (distinctManifestExtensionIds.length === 1) {
+            return {
+                extensionId: distinctManifestExtensionIds[0],
+                source: 'registered',
+            };
+        }
+        if (registeredExtensionId && distinctManifestExtensionIds.includes(registeredExtensionId)) {
+            return {
+                extensionId: registeredExtensionId,
+                source: 'registered',
+            };
+        }
+        return resolved;
+    }
+    const registrationNotReliablyInspectable = opts.manifestParseStatus === 'parse_error' ||
+        opts.manifestExists === null ||
+        opts.manifestExists === false ||
+        opts.manifestParseStatus === 'unavailable';
+    if (registrationNotReliablyInspectable && registeredExtensionId) {
+        return {
+            extensionId: registeredExtensionId,
+            source: 'registered',
+        };
+    }
+    return resolved;
+}
+export function hasAmbiguousManifestExtensionIds(opts) {
+    const resolved = resolveExtensionIdFromSources(opts);
+    if (resolved.source !== 'default' || opts.preferPackagedDefaultExtensionId) {
+        return false;
+    }
+    const registeredExtensionId = isValidExtensionId(opts.registeredExtensionId)
+        ? opts.registeredExtensionId
+        : undefined;
+    const distinctManifestExtensionIds = Array.isArray(opts.manifestExtensionIds)
+        ? Array.from(new Set(opts.manifestExtensionIds.filter((value) => isValidExtensionId(value))))
+        : [];
+    return opts.manifestParseStatus === 'parsed'
+        && distinctManifestExtensionIds.length > 1
+        && (!registeredExtensionId || !distinctManifestExtensionIds.includes(registeredExtensionId));
+}
+export function resolveRegistrationExtensionId(extensionId) {
+    return resolveRegistrationExtensionIdFromSources({
+        extensionId,
+        envExtensionId: process.env[EXTENSION_ID_ENV] || process.env[LEGACY_EXTENSION_ID_ENV],
+        configuredExtensionId: config.get('extensionId'),
+        registeredExtensionId: config.get('registeredExtensionId'),
+        preferPackagedDefaultExtensionId: config.get('preferPackagedDefaultExtensionId'),
+        manifestExtensionIds: null,
+        manifestParseStatus: 'unavailable',
+        manifestExists: null,
+    });
+}
+function getManifestDetails(manifestPath) {
+    if (!manifestPath || manifestPath === '(registry)' || !existsSync(manifestPath)) {
+        return {
+            manifestAllowedOrigins: null,
+            manifestExtensionIds: null,
+            manifestParseStatus: 'unavailable',
+            manifestParseError: null,
+        };
+    }
+    try {
+        const raw = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        const allowedOrigins = Array.isArray(raw.allowed_origins)
+            ? raw.allowed_origins.filter((value) => typeof value === 'string')
+            : [];
+        const manifestExtensionIds = allowedOrigins
+            .map((origin) => {
+            const match = origin.match(/^chrome-extension:\/\/([a-p]{32})\/$/);
+            return match?.[1] ?? null;
+        })
+            .filter((value) => value !== null);
+        return {
+            manifestAllowedOrigins: allowedOrigins,
+            manifestExtensionIds,
+            manifestParseStatus: 'parsed',
+            manifestParseError: null,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            manifestAllowedOrigins: null,
+            manifestExtensionIds: null,
+            manifestParseStatus: 'parse_error',
+            manifestParseError: message,
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// Platform detection (Rosetta 2 aware)
+// ---------------------------------------------------------------------------
+function getPlatform() {
+    const p = process.platform;
+    const a = process.arch;
+    if (p === 'darwin') {
+        // Use sysctl to detect true hardware arch — process.arch/uname return x64
+        // under Rosetta 2.  The native host binary runs as its own process, so the
+        // arm64 build works on Apple Silicon even when Node/Bun is an x64 binary.
+        let hwArch = a;
+        try {
+            const result = spawnSync('sysctl', ['-n', 'hw.optional.arm64'], {
+                encoding: 'utf8',
+                timeout: 2000,
+            });
+            if (result.stdout && result.stdout.trim() === '1')
+                hwArch = 'arm64';
+        }
+        catch { /* fall back to process.arch */ }
+        return { os: 'mac', arch: hwArch === 'arm64' ? 'arm64' : 'x64', ext: '' };
+    }
+    if (p === 'linux' && a === 'arm64')
+        return { os: 'linux', arch: 'arm64', ext: '' };
+    if (p === 'linux')
+        return { os: 'linux', arch: 'x64', ext: '' };
+    if (p === 'win32')
+        return { os: 'windows', arch: 'x64', ext: '.exe' };
+    return null;
+}
+// ---------------------------------------------------------------------------
+// URLs
+// ---------------------------------------------------------------------------
+export function buildBaseUrl(version) {
+    const override = process.env[DOWNLOAD_BASE_URL_OVERRIDE_ENV]?.trim()
+        || process.env[LEGACY_INSTALL_BASE_URL_OVERRIDE_ENV]?.trim();
+    const legacyOverride = process.env[LEGACY_DOWNLOAD_BASE_URL_OVERRIDE_ENV]?.trim();
+    const legacyEnabled = process.env[ENABLE_TEST_DOWNLOAD_BASE_URL_ENV] === '1'
+        || process.env[LEGACY_ENABLE_TEST_DOWNLOAD_BASE_URL_ENV] === '1';
+    if (!override && legacyOverride && !legacyEnabled) {
+        process.emitWarning(`${LEGACY_DOWNLOAD_BASE_URL_OVERRIDE_ENV} is deprecated and ignored unless ${LEGACY_ENABLE_TEST_DOWNLOAD_BASE_URL_ENV}=1; prefer ${DOWNLOAD_BASE_URL_OVERRIDE_ENV}.`, { code: 'THINKBROWSE_NATIVE_HOST_BASE_URL_IGNORED' });
+    }
+    const selectedOverride = override || (legacyEnabled ? legacyOverride : undefined);
+    if (selectedOverride === legacyOverride && legacyOverride) {
+        process.emitWarning(`${LEGACY_DOWNLOAD_BASE_URL_OVERRIDE_ENV} is deprecated; use ${DOWNLOAD_BASE_URL_OVERRIDE_ENV} with ${LOOPBACK_DOWNLOAD_OVERRIDE_ENV}=1 instead.`, { code: 'THINKBROWSE_NATIVE_HOST_BASE_URL_DEPRECATED' });
+    }
+    if (selectedOverride) {
+        const allowLoopbackHttp = process.env[LOOPBACK_DOWNLOAD_OVERRIDE_ENV] === '1'
+            || process.env[LEGACY_LOOPBACK_DOWNLOAD_OVERRIDE_ENV] === '1'
+            || legacyEnabled;
+        const parsed = assertSecureDownloadUrl(selectedOverride, { allowLoopbackHttp });
+        const isLoopbackHost = isLoopbackHostname(parsed.hostname);
+        const requiresHttpBypass = parsed.protocol === 'http:';
+        if (!isLoopbackHost || (requiresHttpBypass && !allowLoopbackHttp)) {
+            throw new Error(`${DOWNLOAD_BASE_URL_OVERRIDE_ENV} is only allowed for explicit loopback fixture installs when ${LOOPBACK_DOWNLOAD_OVERRIDE_ENV}=1`);
+        }
+        return parsed.toString().replace(/\/$/, '');
+    }
+    return `https://github.com/${REPO}/releases/download/native-host%2Fv${version}`;
+}
+// ---------------------------------------------------------------------------
+// HTTP helpers (Node built-ins only — no fetch)
+// ---------------------------------------------------------------------------
+export function assertSecureDownloadUrl(url, opts) {
+    const parsed = new URL(url);
+    const isLoopbackHost = isLoopbackHostname(parsed.hostname);
+    const allowLoopbackHttp = opts?.allowLoopbackHttp ?? isLoopbackHttpDownloadAllowed();
+    if (parsed.protocol === 'http:' && isLoopbackHost && allowLoopbackHttp) {
+        return parsed;
+    }
+    if (parsed.protocol !== 'https:') {
+        throw new Error(`Unsupported protocol: ${parsed.protocol}`);
+    }
+    return parsed;
+}
+export function downloadToFile(url, dest, onProgress) {
+    return new Promise((resolve, reject) => {
+        function follow(u, depth) {
+            if (depth > MAX_REDIRECTS) {
+                reject(new Error('Too many redirects'));
+                return;
+            }
+            let parsedUrl;
+            try {
+                parsedUrl = assertSecureDownloadUrl(u, { allowLoopbackHttp: isLoopbackHttpDownloadAllowed() });
+            }
+            catch (error) {
+                reject(error);
+                return;
+            }
+            const getter = parsedUrl.protocol === 'http:' ? httpGet : httpsGet;
+            const req = getter(parsedUrl, { timeout: DOWNLOAD_TIMEOUT_MS }, (res) => {
+                if (res.statusCode === 301 || res.statusCode === 302) {
+                    res.resume(); // drain body so socket can be reused
+                    const location = res.headers.location ?? '';
+                    let parsed;
+                    try {
+                        parsed = new URL(location);
+                    }
+                    catch {
+                        try {
+                            parsed = new URL(location, parsedUrl);
+                        }
+                        catch {
+                            reject(new Error(`Invalid redirect location: ${location}`));
+                            return;
+                        }
+                    }
+                    follow(parsed.toString(), depth + 1);
+                    return;
+                }
+                if (res.statusCode !== 200) {
+                    res.resume();
+                    reject(new Error(`HTTP ${res.statusCode} for ${u}`));
+                    return;
+                }
+                const total = parseInt(res.headers['content-length'] ?? '0', 10);
+                let received = 0;
+                if (onProgress) {
+                    res.on('data', (chunk) => {
+                        received += chunk.length;
+                        const pct = total > 0 ? Math.floor((received / total) * 100) : 0;
+                        onProgress(pct, received, total);
+                    });
+                }
+                const out = createWriteStream(dest);
+                pipeline(res, out).then(resolve).catch(reject);
+            });
+            req.on('error', reject);
+            req.on('timeout', () => req.destroy(new Error('Download timeout')));
+        }
+        follow(url, 0);
+    });
+}
+export function downloadText(url) {
+    return new Promise((resolve, reject) => {
+        function follow(u, depth) {
+            if (depth > MAX_REDIRECTS) {
+                reject(new Error('Too many redirects'));
+                return;
+            }
+            let parsedUrl;
+            try {
+                parsedUrl = assertSecureDownloadUrl(u, { allowLoopbackHttp: isLoopbackHttpDownloadAllowed() });
+            }
+            catch (error) {
+                reject(error);
+                return;
+            }
+            const getter = parsedUrl.protocol === 'http:' ? httpGet : httpsGet;
+            const req = getter(parsedUrl, { timeout: DOWNLOAD_TIMEOUT_MS }, (res) => {
+                if (res.statusCode === 301 || res.statusCode === 302) {
+                    res.resume(); // drain body so socket can be reused
+                    const location = res.headers.location ?? '';
+                    let parsed;
+                    try {
+                        parsed = new URL(location);
+                    }
+                    catch {
+                        try {
+                            parsed = new URL(location, parsedUrl);
+                        }
+                        catch {
+                            reject(new Error(`Invalid redirect location: ${location}`));
+                            return;
+                        }
+                    }
+                    follow(parsed.toString(), depth + 1);
+                    return;
+                }
+                if (res.statusCode !== 200) {
+                    res.resume();
+                    reject(new Error(`HTTP ${res.statusCode}`));
+                    return;
+                }
+                let body = '';
+                res.on('data', (chunk) => { body += chunk.toString(); });
+                res.on('end', () => resolve(body));
+                res.on('error', reject);
+            });
+            req.on('error', reject);
+            req.on('timeout', () => req.destroy(new Error('Download timeout')));
+        }
+        follow(url, 0);
+    });
+}
+// ---------------------------------------------------------------------------
+// Checksum helpers
+// ---------------------------------------------------------------------------
+function sha256file(filePath) {
+    return createHash('sha256').update(readFileSync(filePath)).digest('hex');
+}
+function parseChecksum(checksumsTxt, filename) {
+    for (const line of checksumsTxt.split('\n')) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length === 2 && parts[1].replace(/^\*/, '') === filename)
+            return parts[0];
+    }
+    return null;
+}
+export function canReuseInstalledBinary(opts) {
+    return getInstalledBinaryReuseType(opts) !== 'none';
+}
+export function getInstalledBinaryReuseType(opts) {
+    if (!opts.isExecutable)
+        return 'none';
+    if (opts.installedVersion !== opts.expectedVersion)
+        return 'none';
+    const hasAnyTrustMetadata = typeof opts.storedVersion === 'string' ||
+        typeof opts.storedChecksum === 'string';
+    const hasTrustedMetadata = opts.storedVersion === opts.expectedVersion &&
+        typeof opts.storedChecksum === 'string';
+    if (hasAnyTrustMetadata && !hasTrustedMetadata) {
+        return 'none';
+    }
+    if (!hasTrustedMetadata) {
+        // Legacy installs from older CLI versions may predate persisted trust metadata.
+        // Allow manifest-only repair to reuse a matching executable instead of forcing
+        // a network download just to re-register the native host.
+        return 'legacy';
+    }
+    return opts.storedChecksum === opts.currentChecksum ? 'trusted' : 'none';
+}
+function getInstalledBinaryVersion(binaryPath) {
+    // `binaryPath` is always the fixed legacy install location selected by
+    // installNativeHost/checkNativeHost while the native-host surface is frozen.
+    const result = spawnSync(binaryPath, ['--version'], { encoding: 'utf8', timeout: 3000 }); // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process
+    if (result.status !== 0) {
+        return null;
+    }
+    return result.stdout?.trim().replace(/^thinkbrowse-host\s+/, '').replace(/^v/, '') || null;
+}
+export function replaceInstalledBinary(downloadPath, destPath) {
+    if (process.platform !== 'win32' || !existsSync(destPath)) {
+        renameSync(downloadPath, destPath);
+        return;
+    }
+    const backupPath = `${destPath}.bak`;
+    if (existsSync(backupPath))
+        unlinkSync(backupPath);
+    renameSync(destPath, backupPath);
+    try {
+        renameSync(downloadPath, destPath);
+    }
+    catch (error) {
+        try {
+            if (existsSync(backupPath) && !existsSync(destPath)) {
+                renameSync(backupPath, destPath);
+            }
+        }
+        catch {
+            // Preserve any surviving backup/download artifact for manual recovery.
+        }
+        throw error;
+    }
+    if (existsSync(backupPath)) {
+        try {
+            unlinkSync(backupPath);
+        }
+        catch { /* ignore best-effort backup cleanup */ }
+    }
+}
+// ---------------------------------------------------------------------------
+// Progress bar renderer
+// ---------------------------------------------------------------------------
+function renderProgressBar(pct, received, total, filename) {
+    const BAR_WIDTH = 20;
+    const filled = Math.floor((pct / 100) * BAR_WIDTH);
+    const bar = '='.repeat(filled) + (filled < BAR_WIDTH ? '>' : '') + ' '.repeat(Math.max(0, BAR_WIDTH - filled - 1));
+    const receivedMb = (received / 1_048_576).toFixed(1);
+    const totalMb = total > 0 ? ` / ${(total / 1_048_576).toFixed(1)} MB` : '';
+    const line = `  Downloading ${filename} [${bar}] ${pct}% (${receivedMb} MB${totalMb})`;
+    process.stdout.write(`\r${line}`);
+}
+const DEFAULT_PROFILE_MARKERS = ['Local State', 'Default', 'First Run', 'Last Version'];
+function getManifestTargets() {
+    if (process.platform === 'darwin') {
+        const appSupport = join(homedir(), 'Library', 'Application Support');
+        return [
+            { browserName: 'Chrome', detectionDir: join(appSupport, 'Google', 'Chrome'), manifestPath: join(appSupport, 'Google', 'Chrome', 'NativeMessagingHosts', 'com.thinkbrowse.host.json'), installPaths: ['/Applications/Google Chrome.app', join(homedir(), 'Applications', 'Google Chrome.app')], profileMarkers: [...DEFAULT_PROFILE_MARKERS] },
+            { browserName: 'Chrome Canary', detectionDir: join(appSupport, 'Google', 'Chrome Canary'), manifestPath: join(appSupport, 'Google', 'Chrome Canary', 'NativeMessagingHosts', 'com.thinkbrowse.host.json'), installPaths: ['/Applications/Google Chrome Canary.app', join(homedir(), 'Applications', 'Google Chrome Canary.app')], profileMarkers: [...DEFAULT_PROFILE_MARKERS] },
+            { browserName: 'Chromium', detectionDir: join(appSupport, 'Chromium'), manifestPath: join(appSupport, 'Chromium', 'NativeMessagingHosts', 'com.thinkbrowse.host.json'), installPaths: ['/Applications/Chromium.app', join(homedir(), 'Applications', 'Chromium.app')], profileMarkers: [...DEFAULT_PROFILE_MARKERS] },
+            { browserName: 'Brave', detectionDir: join(appSupport, 'BraveSoftware', 'Brave-Browser'), manifestPath: join(appSupport, 'BraveSoftware', 'Brave-Browser', 'NativeMessagingHosts', 'com.thinkbrowse.host.json'), installPaths: ['/Applications/Brave Browser.app', join(homedir(), 'Applications', 'Brave Browser.app')], profileMarkers: [...DEFAULT_PROFILE_MARKERS] },
+            { browserName: 'Edge', detectionDir: join(appSupport, 'Microsoft Edge'), manifestPath: join(appSupport, 'Microsoft Edge', 'NativeMessagingHosts', 'com.thinkbrowse.host.json'), installPaths: ['/Applications/Microsoft Edge.app', join(homedir(), 'Applications', 'Microsoft Edge.app')], profileMarkers: [...DEFAULT_PROFILE_MARKERS] },
+            { browserName: 'Helium', detectionDir: join(appSupport, 'net.imput.helium'), manifestPath: join(appSupport, 'net.imput.helium', 'NativeMessagingHosts', 'com.thinkbrowse.host.json'), installPaths: ['/Applications/Helium.app', join(homedir(), 'Applications', 'Helium.app')], profileMarkers: [...DEFAULT_PROFILE_MARKERS] },
+            { browserName: 'Vivaldi', detectionDir: join(appSupport, 'Vivaldi'), manifestPath: join(appSupport, 'Vivaldi', 'NativeMessagingHosts', 'com.thinkbrowse.host.json'), installPaths: ['/Applications/Vivaldi.app', join(homedir(), 'Applications', 'Vivaldi.app')], profileMarkers: [...DEFAULT_PROFILE_MARKERS] },
+            { browserName: 'Opera', detectionDir: join(appSupport, 'com.operasoftware.Opera'), manifestPath: join(appSupport, 'com.operasoftware.Opera', 'NativeMessagingHosts', 'com.thinkbrowse.host.json'), installPaths: ['/Applications/Opera.app', join(homedir(), 'Applications', 'Opera.app')], profileMarkers: [...DEFAULT_PROFILE_MARKERS] },
+        ];
+    }
+    if (process.platform === 'linux') {
+        const configDir = join(homedir(), '.config');
+        return [
+            { browserName: 'Chrome', detectionDir: join(configDir, 'google-chrome'), manifestPath: join(configDir, 'google-chrome', 'NativeMessagingHosts', 'com.thinkbrowse.host.json'), installPaths: ['/usr/bin/google-chrome', '/usr/bin/google-chrome-stable'], profileMarkers: [...DEFAULT_PROFILE_MARKERS] },
+            { browserName: 'Chromium', detectionDir: join(configDir, 'chromium'), manifestPath: join(configDir, 'chromium', 'NativeMessagingHosts', 'com.thinkbrowse.host.json'), installPaths: ['/usr/bin/chromium', '/usr/bin/chromium-browser', '/snap/bin/chromium'], profileMarkers: [...DEFAULT_PROFILE_MARKERS] },
+            { browserName: 'Brave', detectionDir: join(configDir, 'BraveSoftware', 'Brave-Browser'), manifestPath: join(configDir, 'BraveSoftware', 'Brave-Browser', 'NativeMessagingHosts', 'com.thinkbrowse.host.json'), installPaths: ['/usr/bin/brave-browser', '/opt/brave.com/brave/brave-browser'], profileMarkers: [...DEFAULT_PROFILE_MARKERS] },
+            { browserName: 'Edge', detectionDir: join(configDir, 'microsoft-edge'), manifestPath: join(configDir, 'microsoft-edge', 'NativeMessagingHosts', 'com.thinkbrowse.host.json'), installPaths: ['/usr/bin/microsoft-edge', '/opt/microsoft/msedge/msedge'], profileMarkers: [...DEFAULT_PROFILE_MARKERS] },
+            { browserName: 'Vivaldi', detectionDir: join(configDir, 'vivaldi'), manifestPath: join(configDir, 'vivaldi', 'NativeMessagingHosts', 'com.thinkbrowse.host.json'), installPaths: ['/usr/bin/vivaldi', '/opt/vivaldi/vivaldi'], profileMarkers: [...DEFAULT_PROFILE_MARKERS] },
+        ];
+    }
+    return [];
+}
+function isBrowserInstalled(target) {
+    if (target.installPaths && target.installPaths.length > 0) {
+        if (target.installPaths.some((path) => existsSync(path))) {
+            return true;
+        }
+        if (!existsSync(target.detectionDir)) {
+            return false;
+        }
+        const markers = target.profileMarkers ?? [];
+        if (markers.length === 0) {
+            return true;
+        }
+        return markers.some((marker) => SAFE_PROFILE_MARKER.test(marker) && existsSync(markerPath(target.detectionDir, marker)));
+    }
+    return existsSync(target.detectionDir);
+}
+export function inspectNativeHostManifest(targets) {
+    if (process.platform === 'win32') {
+        return {
+            manifestExists: null,
+            manifestPath: '(registry)',
+            manifestAllowedOrigins: null,
+            manifestExtensionIds: null,
+            manifestParseStatus: 'unavailable',
+            manifestParseError: null,
+            manifestEntries: null,
+        };
+    }
+    const manifestTargets = targets ?? getManifestTargets();
+    const manifestEntries = manifestTargets.map((target) => {
+        const browserDetected = isBrowserInstalled(target);
+        const manifestExists = existsSync(target.manifestPath);
+        const details = manifestExists ? getManifestDetails(target.manifestPath) : getManifestDetails(null);
+        return {
+            browserName: target.browserName,
+            detectionDir: target.detectionDir,
+            manifestPath: target.manifestPath,
+            browserDetected,
+            manifestExists,
+            manifestAllowedOrigins: details.manifestAllowedOrigins,
+            manifestExtensionIds: details.manifestExtensionIds,
+            manifestParseStatus: details.manifestParseStatus,
+            manifestParseError: details.manifestParseError,
+            relevant: browserDetected,
+        };
+    });
+    const relevantEntries = manifestEntries.filter((entry) => entry.relevant);
+    const relevantExistingEntries = relevantEntries.filter((entry) => entry.manifestExists);
+    const parsedEntries = relevantExistingEntries.filter((entry) => entry.manifestParseStatus === 'parsed');
+    const parseErrors = relevantExistingEntries.filter((entry) => entry.manifestParseStatus === 'parse_error');
+    const manifestExists = relevantEntries.length > 0 && relevantEntries.every((entry) => entry.manifestExists);
+    const preferredEntries = relevantEntries.length > 0 ? relevantEntries : manifestEntries;
+    const preferredExistingEntries = preferredEntries.filter((entry) => entry.manifestExists);
+    const manifestPath = manifestExists
+        ? preferredExistingEntries.length === 1
+            ? preferredExistingEntries[0].manifestPath
+            : `${preferredExistingEntries[0].manifestPath} (+${preferredExistingEntries.length - 1} more)`
+        : preferredEntries.find((entry) => !entry.manifestExists)?.manifestPath ??
+            preferredEntries[0]?.manifestPath ??
+            '(no known manifest path)';
+    const allowedOrigins = Array.from(new Set(parsedEntries.flatMap((entry) => entry.manifestAllowedOrigins ?? [])));
+    const extensionIds = Array.from(new Set(parsedEntries.flatMap((entry) => entry.manifestExtensionIds ?? [])));
+    const manifestParseStatus = parseErrors.length > 0
+        ? 'parse_error'
+        : parsedEntries.length > 0
+            ? 'parsed'
+            : 'unavailable';
+    const manifestParseError = parseErrors.length > 0
+        ? parseErrors.map((entry) => `${entry.manifestPath}: ${entry.manifestParseError ?? 'parse error'}`).join('; ')
+        : null;
+    return {
+        manifestExists,
+        manifestPath,
+        manifestAllowedOrigins: allowedOrigins.length > 0 ? allowedOrigins : null,
+        manifestExtensionIds: extensionIds.length > 0 ? extensionIds : null,
+        manifestParseStatus,
+        manifestParseError,
+        manifestEntries,
+    };
+}
+// ---------------------------------------------------------------------------
+// Core logic: check existing installation
+// ---------------------------------------------------------------------------
+export async function checkNativeHost(opts = {}) {
+    const pkg = JSON.parse(readFileSync(PKG_JSON_PATH, 'utf8'));
+    const expectedVersion = pkg.nativeHostVersion ?? '0.0.0';
+    const platform = getPlatform();
+    const platformLabel = platform ? `${platform.os}-${platform.arch}` : 'unknown';
+    const ext = platform?.ext ?? '';
+    const binaryPath = join(INSTALL_DIR, BINARY_NAME + ext);
+    const manifestState = inspectNativeHostManifest();
+    if (!existsSync(binaryPath)) {
+        return {
+            binaryExists: false,
+            binaryPath,
+            installedVersion: null,
+            expectedVersion,
+            versionMatch: false,
+            checksumVerified: null,
+            manifestExists: manifestState.manifestExists,
+            manifestPath: manifestState.manifestPath,
+            platform: platformLabel,
+            manifestAllowedOrigins: manifestState.manifestAllowedOrigins,
+            manifestExtensionIds: manifestState.manifestExtensionIds,
+            manifestParseStatus: manifestState.manifestParseStatus,
+            manifestParseError: manifestState.manifestParseError,
+            manifestEntries: manifestState.manifestEntries,
+        };
+    }
+    // Get installed version
+    let installedVersion = null;
+    try {
+        const result = spawnSync(binaryPath, ['--version'], { encoding: 'utf8', timeout: 3000 });
+        const raw = result.stdout?.trim() ?? '';
+        // Output is "thinkbrowse-host 1.0.3" — extract just the version number
+        installedVersion = raw.replace(/^thinkbrowse-host\s+/, '').replace(/^v/, '') || null;
+    }
+    catch { /* ignore */ }
+    const versionMatch = installedVersion === expectedVersion;
+    // Checksum verify — only performed when explicitly requested (--full / install --check)
+    // to avoid a remote round-trip on every `thinkrun doctor` call.
+    // When versions differ, verify against the installed version's checksums (not expectedVersion)
+    // so we report file integrity, not "does the old binary match the new release".
+    let checksumVerified = null;
+    if (opts.verifyChecksum && platform) {
+        const filename = `thinkbrowse-host-${platform.os}-${platform.arch}${platform.ext}`;
+        const versionToVerify = installedVersion ?? expectedVersion;
+        try {
+            const checksumsUrl = `${buildBaseUrl(versionToVerify)}/checksums.txt`;
+            const checksumsTxt = await downloadText(checksumsUrl);
+            const expected = parseChecksum(checksumsTxt, filename);
+            if (expected) {
+                checksumVerified = sha256file(binaryPath) === expected;
+            }
+        }
+        catch {
+            checksumVerified = null; /* offline or version not in releases */
+        }
+    }
+    return {
+        binaryExists: true,
+        binaryPath,
+        installedVersion,
+        expectedVersion,
+        versionMatch,
+        checksumVerified,
+        manifestExists: manifestState.manifestExists,
+        manifestPath: manifestState.manifestPath,
+        platform: platformLabel,
+        manifestAllowedOrigins: manifestState.manifestAllowedOrigins,
+        manifestExtensionIds: manifestState.manifestExtensionIds,
+        manifestParseStatus: manifestState.manifestParseStatus,
+        manifestParseError: manifestState.manifestParseError,
+        manifestEntries: manifestState.manifestEntries,
+    };
+}
+// ---------------------------------------------------------------------------
+// Core logic: install
+// ---------------------------------------------------------------------------
+export async function installNativeHost(opts) {
+    const pkg = JSON.parse(readFileSync(PKG_JSON_PATH, 'utf8'));
+    const VERSION = pkg.nativeHostVersion ?? '0.0.0';
+    const platform = getPlatform();
+    if (!platform) {
+        console.log(chalk.yellow('  Unsupported platform — cannot install native host.'));
+        return false;
+    }
+    const platformLabel = `${platform.os}-${platform.arch}`;
+    const filename = `thinkbrowse-host-${platformLabel}${platform.ext}`;
+    const dest = join(INSTALL_DIR, BINARY_NAME + platform.ext);
+    const downloadDest = `${dest}.download`;
+    const resolvedExtensionId = opts.resolvedExtensionId ?? resolveRegistrationExtensionId(opts.extensionId);
+    let binaryAlreadyInstalled = false;
+    let verifiedBinaryChecksum = null;
+    let persistVerifiedChecksum = false;
+    let legacyInstalledChecksum = null;
+    let binaryUrl = '';
+    let checksumsUrl = '';
+    console.log(chalk.bold(`Installing for ${platformLabel}`));
+    if (resolvedExtensionId.source === 'default') {
+        console.log(`  ${chalk.yellow('!')} Using packaged extension ID ${resolvedExtensionId.extensionId}.`);
+        console.log(`    If you loaded an unpacked/dev extension, run ${chalk.cyan('thinkrun config set-extension-id <id>')} first.`);
+    }
+    // --- Skip check (unless --force) ---
+    if (!opts.force && existsSync(dest)) {
+        try {
+            const storedVersion = config.get('nativeHostVersion');
+            const storedChecksum = config.get('nativeHostChecksum');
+            const currentChecksum = sha256file(dest);
+            const isExecutable = platform.ext === '.exe' ||
+                (statSync(dest).mode & 0o111) !== 0;
+            const trustedChecksumMatch = storedVersion === VERSION &&
+                typeof storedChecksum === 'string' &&
+                storedChecksum === currentChecksum;
+            if (trustedChecksumMatch) {
+                // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process
+                // `dest` stays in the frozen ~/.thinkbrowse/bin install location during the internal pass.
+                const reuseType = getInstalledBinaryReuseType({
+                    storedVersion,
+                    storedChecksum,
+                    currentChecksum,
+                    installedVersion: getInstalledBinaryVersion(dest),
+                    expectedVersion: VERSION,
+                    isExecutable,
+                });
+                if (reuseType === 'trusted') {
+                    console.log(`  ${chalk.green('✓')} Already installed at v${VERSION} — skipping download.`);
+                    console.log(`    Re-registering manifest for extension ${chalk.cyan(resolvedExtensionId.extensionId)}.`);
+                    verifiedBinaryChecksum = currentChecksum;
+                    persistVerifiedChecksum = true;
+                    binaryAlreadyInstalled = true;
+                }
+            }
+            else if (!storedVersion && !storedChecksum && isExecutable) {
+                legacyInstalledChecksum = currentChecksum;
+            }
+        }
+        catch { /* could not check — proceed with install */ }
+    }
+    if (!binaryAlreadyInstalled) {
+        // --- Ensure install dir ---
+        if (!existsSync(INSTALL_DIR))
+            mkdirSync(INSTALL_DIR, { recursive: true });
+        try {
+            const baseUrl = buildBaseUrl(VERSION);
+            binaryUrl = `${baseUrl}/${filename}`;
+            checksumsUrl = `${baseUrl}/checksums.txt`;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.log(`  ${chalk.red('✗')} Download configuration invalid: ${message}`);
+            console.log(`    Clear deprecated override env vars or rerun with a loopback fixture override only.`);
+            return false;
+        }
+        // --- Step 1: Download checksums ---
+        let checksumsTxt;
+        try {
+            checksumsTxt = await downloadText(checksumsUrl);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.log(`  ${chalk.red('✗')} Could not fetch checksums: ${msg}`);
+            console.log(`    Run ${chalk.cyan('thinkrun install --force')} to retry`);
+            return false;
+        }
+        if (!binaryAlreadyInstalled) {
+            const expectedHash = parseChecksum(checksumsTxt, filename);
+            if (!expectedHash) {
+                console.log(`  ${chalk.red('✗')} No checksum entry for ${filename}`);
+                console.log(`    Run ${chalk.cyan('thinkrun install --force')} to retry`);
+                return false;
+            }
+            if (legacyInstalledChecksum && legacyInstalledChecksum === expectedHash) {
+                // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process
+                // `dest` stays in the frozen ~/.thinkbrowse/bin install location during the internal pass.
+                const installedVersion = getInstalledBinaryVersion(dest);
+                if (installedVersion === VERSION) {
+                    console.log(`  ${chalk.green('✓')} Existing binary matches the published checksum for v${VERSION}.`);
+                    console.log(`    Re-registering manifest for extension ${chalk.cyan(resolvedExtensionId.extensionId)}.`);
+                    verifiedBinaryChecksum = legacyInstalledChecksum;
+                    persistVerifiedChecksum = true;
+                    binaryAlreadyInstalled = true;
+                }
+            }
+            if (!binaryAlreadyInstalled) {
+                // --- Step 2: Download binary with progress ---
+                try {
+                    try {
+                        if (existsSync(downloadDest))
+                            unlinkSync(downloadDest);
+                    }
+                    catch { /* ignore */ }
+                    await downloadToFile(binaryUrl, downloadDest, (pct, received, total) => {
+                        renderProgressBar(pct, received, total, filename);
+                    });
+                    // Move to new line after progress bar finishes
+                    process.stdout.write('\n');
+                }
+                catch (err) {
+                    process.stdout.write('\n');
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.log(`  ${chalk.red('✗')} Download failed: ${msg}`);
+                    try {
+                        if (existsSync(downloadDest))
+                            unlinkSync(downloadDest);
+                    }
+                    catch { /* ignore */ }
+                    console.log(`    Run ${chalk.cyan('thinkrun install --force')} to retry`);
+                    return false;
+                }
+                // --- Step 3: Verify checksum ---
+                const actualHash = sha256file(downloadDest);
+                if (actualHash !== expectedHash) {
+                    console.log(`  ${chalk.red('✗')} Checksum mismatch for ${filename}`);
+                    console.log(`    expected: ${expectedHash}`);
+                    console.log(`    actual:   ${actualHash}`);
+                    console.log('    Binary deleted — possible tampering.');
+                    try {
+                        unlinkSync(downloadDest);
+                    }
+                    catch { /* ignore */ }
+                    console.log(`    Run ${chalk.cyan('thinkrun install --force')} to retry`);
+                    return false;
+                }
+                verifiedBinaryChecksum = actualHash;
+                persistVerifiedChecksum = true;
+                console.log(`  ${chalk.green('✓')} Checksum: verified`);
+                // --- Step 4: Make executable ---
+                if (platform.ext !== '.exe')
+                    chmodSync(downloadDest, 0o755);
+                try {
+                    replaceInstalledBinary(downloadDest, dest);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.log(`  ${chalk.red('✗')} Install failed while replacing the local binary: ${msg}`);
+                    try {
+                        if (existsSync(downloadDest))
+                            unlinkSync(downloadDest);
+                    }
+                    catch { /* ignore */ }
+                    console.log(`    Close Chrome/Helium or any running thinkbrowse-host process, then run ${chalk.cyan('thinkrun install --force')} to retry.`);
+                    return false;
+                }
+            }
+        }
+    }
+    // --- Step 5: Register native messaging manifest ---
+    try {
+        const result = spawnSync(dest, ['--install', '--extension-id', resolvedExtensionId.extensionId], {
+            encoding: 'utf8',
+            timeout: 10000,
+        });
+        if (result.status === 0) {
+            if (persistVerifiedChecksum && verifiedBinaryChecksum) {
+                config.set('nativeHostVersion', VERSION);
+                config.set('nativeHostChecksum', verifiedBinaryChecksum);
+            }
+            if (shouldClearPackagedDefaultPreference(resolvedExtensionId.source)) {
+                config.delete('preferPackagedDefaultExtensionId');
+            }
+            console.log(`  ${chalk.green('✓')} Manifest: registered for extension ${resolvedExtensionId.extensionId}`);
+        }
+        else {
+            const errOut = result.stderr?.trim() ?? '';
+            console.log(`  ${chalk.yellow('!')} Manifest registration exited ${result.status}${errOut ? `: ${errOut}` : ''}`);
+            return false;
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(`  ${chalk.yellow('!')} Manifest registration failed: ${msg}`);
+        return false;
+    }
+    console.log('');
+    console.log(`  ${chalk.green('✓')} Native host v${VERSION} installed successfully.`);
+    console.log('    Open a Chromium-based browser (e.g. Chrome or Helium) — the ThinkRun extension will start the host automatically.');
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Check-only mode
+// ---------------------------------------------------------------------------
+async function runCheckOnly() {
+    console.log(chalk.bold('Native Host Check'));
+    console.log('');
+    const result = await checkNativeHost({ verifyChecksum: true });
+    console.log(`  Platform: ${result.platform}`);
+    console.log('');
+    if (!result.binaryExists) {
+        console.log(`  ${chalk.red('✗')} Binary:   not found`);
+        console.log(`    Run: ${chalk.cyan('thinkrun install')}`);
+        return;
+    }
+    const versionLabel = result.installedVersion
+        ? result.versionMatch
+            ? `v${result.installedVersion}`
+            : `v${result.installedVersion} ${chalk.yellow(`(outdated — expected v${result.expectedVersion})`)}`
+        : 'unknown version';
+    console.log(`  ${result.versionMatch ? chalk.green('✓') : chalk.yellow('!')} Binary:   ${result.binaryPath} (${versionLabel})`);
+    if (result.checksumVerified === true) {
+        console.log(`  ${chalk.green('✓')} Checksum: verified`);
+    }
+    else if (result.checksumVerified === false) {
+        console.log(`  ${chalk.red('✗')} Checksum: mismatch`);
+    }
+    else {
+        console.log(`  ${chalk.gray('-')} Checksum: could not verify (offline?)`);
+    }
+    const manifestOk = result.manifestExists || process.platform === 'win32';
+    if (process.platform === 'win32') {
+        console.log(`  ${chalk.gray('-')} Manifest: N/A (Windows — registry-based)`);
+    }
+    else {
+        if (result.manifestParseStatus === 'parse_error') {
+            console.log(`  ${chalk.red('✗')} Manifest: unreadable (${result.manifestParseError ?? 'could not read native messaging manifest'})`);
+            console.log(`    Run: ${chalk.cyan('thinkrun setup')}`);
+        }
+        else {
+            console.log(`  ${manifestOk ? chalk.green('✓') : chalk.red('✗')} Manifest: ${manifestOk ? 'registered' : `not found at ${result.manifestPath}`}`);
+        }
+    }
+    if (!result.versionMatch) {
+        console.log('');
+        console.log(`    Run: ${chalk.cyan('thinkrun install --force')}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Command factory
+// ---------------------------------------------------------------------------
+export function createInstallCommand() {
+    return new Command('install')
+        .description('Download, verify, and register the native host binary')
+        .option('--force', 'reinstall even if already at the correct version')
+        .option('--check', 'verify existing binary only (no download)')
+        .option('--extension-id <id>', 'register the native host for a specific Chrome extension ID')
+        .action(async (opts) => {
+        if (opts.check) {
+            await runCheckOnly();
+            return;
+        }
+        if (opts.extensionId) {
+            if (!isValidExtensionId(opts.extensionId)) {
+                console.log(chalk.red('Error: invalid extension ID. Expected 32 lowercase letters in the range a-p.'));
+                process.exitCode = 1;
+                return;
+            }
+        }
+        const manifestState = inspectNativeHostManifest();
+        if (hasAmbiguousManifestExtensionIds({
+            extensionId: opts.extensionId,
+            envExtensionId: process.env[EXTENSION_ID_ENV] || process.env[LEGACY_EXTENSION_ID_ENV],
+            configuredExtensionId: config.get('extensionId'),
+            registeredExtensionId: config.get('registeredExtensionId'),
+            preferPackagedDefaultExtensionId: config.get('preferPackagedDefaultExtensionId') === true,
+            manifestExtensionIds: manifestState.manifestExtensionIds,
+            manifestParseStatus: manifestState.manifestParseStatus,
+        })) {
+            console.log(chalk.red('Error: detected browser manifests disagree on the ThinkRun extension ID.'));
+            console.log(`  Run ${chalk.cyan('thinkrun config set-extension-id <id>')} or pass ${chalk.cyan('--extension-id <id>')}, then rerun ${chalk.cyan('thinkrun install')}.`);
+            process.exitCode = 1;
+            return;
+        }
+        const resolvedExtensionId = resolveRegistrationExtensionIdFromSources({
+            extensionId: opts.extensionId,
+            envExtensionId: process.env[EXTENSION_ID_ENV] || process.env[LEGACY_EXTENSION_ID_ENV],
+            configuredExtensionId: config.get('extensionId'),
+            registeredExtensionId: config.get('registeredExtensionId'),
+            preferPackagedDefaultExtensionId: config.get('preferPackagedDefaultExtensionId') === true,
+            manifestExtensionIds: manifestState.manifestExtensionIds,
+            manifestParseStatus: manifestState.manifestParseStatus,
+            manifestExists: manifestState.manifestExists,
+        });
+        const success = await installNativeHost({
+            force: opts.force ?? false,
+            extensionId: opts.extensionId,
+            resolvedExtensionId,
+        });
+        if (success) {
+            config.set('registeredExtensionId', resolvedExtensionId.extensionId);
+        }
+        if (!success) {
+            process.exitCode = 1;
+        }
+    });
+}
+//# sourceMappingURL=install.js.map