orquesta-cli 0.2.106 → 0.2.108

package/dist/cli.js

@@ -28,7 +28,7 @@ import { sessionManager } from './core/session/session-manager.js';
 import { connectWithToken, showConnectionStatus, disconnectFromOrquesta, switchProject } from './setup/first-run-setup.js';
 import { syncOrquestaConfigs } from './orquesta/config-sync.js';
 import { scanProviders, scanProvider, toEndpointConfig } from './core/config/auto-detect.js';
-import { PROVIDERS } from './core/config/providers.js';
+import { getProviders, refreshCatalogFromServer } from './core/config/providers.js';
 import { shouldShowOnboarding, runOnboarding } from './core/onboarding.js';
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
@@ -224,7 +224,7 @@ program
                 console.log(chalk.yellow('\nNo LLM providers detected.'));
                 console.log(chalk.dim('Set environment variables (e.g., OPENAI_API_KEY) or start a local provider (Ollama, LM Studio).'));
                 console.log(chalk.dim('\nSupported providers:'));
-                for (const p of PROVIDERS) {
+                for (const p of getProviders()) {
                     const envHint = p.envVars.length > 0 ? chalk.dim(` (${p.envVars[0]})`) : p.isLocal ? chalk.dim(` (port ${p.localPort})`) : '';
                     console.log(chalk.white(`  ${p.name}${envHint}`));
                 }
@@ -265,7 +265,7 @@ program
             const detected = await scanProvider(options.addProvider);
             if (!detected) {
                 spinner.fail(chalk.red(`Provider '${options.addProvider}' not found or not available`));
-                const provider = PROVIDERS.find(p => p.id === options.addProvider);
+                const provider = getProviders().find(p => p.id === options.addProvider);
                 if (provider && provider.envVars.length > 0) {
                     console.log(chalk.dim(`Set ${provider.envVars[0]} environment variable and try again.`));
                 }
@@ -495,5 +495,6 @@ program.on('command:*', () => {
     console.log(chalk.white('\nUse /help in interactive mode for more help.\n'));
     process.exit(1);
 });
+void refreshCatalogFromServer();
 program.parse(process.argv);
 //# sourceMappingURL=cli.js.map

package/dist/core/config/auto-detect.js

@@ -1,9 +1,9 @@
 import axios from 'axios';
-import { PROVIDERS, buildAuthHeaders } from './providers.js';
+import { getProviders, buildAuthHeaders } from './providers.js';
 export async function scanProviders() {
     const detected = [];
     const notFound = [];
-    for (const provider of PROVIDERS.filter((p) => !p.isLocal)) {
+    for (const provider of getProviders().filter((p) => !p.isLocal)) {
         const apiKey = findEnvVar(provider.envVars);
         if (apiKey) {
             const models = await fetchModels(provider, apiKey).catch(() => []);
@@ -18,7 +18,7 @@ export async function scanProviders() {
             notFound.push(provider.id);
         }
     }
-    const localProbes = PROVIDERS.filter((p) => p.isLocal).map(async (provider) => {
+    const localProbes = getProviders().filter((p) => p.isLocal).map(async (provider) => {
         const running = await probeLocal(provider);
         if (running) {
             const models = await fetchModels(provider, '').catch(() => []);
@@ -36,7 +36,7 @@ export async function scanProviders() {
     return { detected, notFound };
 }
 export async function scanProvider(providerId, apiKey) {
-    const provider = PROVIDERS.find((p) => p.id === providerId);
+    const provider = getProviders().find((p) => p.id === providerId);
     if (!provider)
         return null;
     const key = apiKey || findEnvVar(provider.envVars) || '';

package/dist/core/config/providers.d.ts

@@ -22,6 +22,9 @@ export interface ProviderDefinition {
     healthCheckPath?: string;
 }
 export declare const PROVIDERS: ProviderDefinition[];
+export declare function refreshCatalogFromServer(timeoutMs?: number): Promise<boolean>;
+export declare function getCatalogVersion(): number;
+export declare function getProviders(): ProviderDefinition[];
 export declare function getProvider(id: string): ProviderDefinition | undefined;
 export declare function detectProviderFromUrl(baseUrl: string): ProviderDefinition | undefined;
 export declare function modelHasCapability(providerId: string, modelId: string, capability: ModelCapability): boolean;

package/dist/core/config/providers.js

@@ -1,3 +1,6 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
 export const PROVIDERS = [
     {
         id: 'openai',
@@ -302,17 +305,98 @@ export const PROVIDERS = [
         knownModels: [],
     },
 ];
+const CATALOG_CACHE_DIR = path.join(os.homedir(), '.orquesta-cli');
+const CATALOG_CACHE_FILE = path.join(CATALOG_CACHE_DIR, 'catalog.json');
+const CATALOG_ENDPOINT_PATH = '/api/orquesta-cli/catalog';
+let effectiveProviders = PROVIDERS;
+let effectiveVersion = 0;
+function overlayProviders(incoming) {
+    const byId = new Map();
+    for (const p of PROVIDERS)
+        byId.set(p.id, p);
+    for (const p of incoming) {
+        if (p && typeof p.id === 'string' && Array.isArray(p.knownModels)) {
+            byId.set(p.id, p);
+        }
+    }
+    return Array.from(byId.values());
+}
+function isValidCatalogProviders(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((p) => p &&
+            typeof p.id === 'string' &&
+            typeof p.baseUrl === 'string' &&
+            Array.isArray(p.knownModels)));
+}
+function seedCatalogFromDisk() {
+    try {
+        const raw = fs.readFileSync(CATALOG_CACHE_FILE, 'utf-8');
+        const cache = JSON.parse(raw);
+        if (isValidCatalogProviders(cache.providers)) {
+            effectiveProviders = overlayProviders(cache.providers);
+            effectiveVersion = typeof cache.version === 'number' ? cache.version : 0;
+        }
+    }
+    catch {
+    }
+}
+seedCatalogFromDisk();
+function catalogUrl() {
+    const base = process.env['ORQUESTA_API_URL'] || 'https://getorquesta.com';
+    return base.replace(/\/$/, '') + CATALOG_ENDPOINT_PATH;
+}
+export async function refreshCatalogFromServer(timeoutMs = 4000) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        const res = await fetch(catalogUrl(), {
+            signal: controller.signal,
+            headers: { Accept: 'application/json' },
+        });
+        clearTimeout(timer);
+        if (!res.ok)
+            return false;
+        const json = (await res.json());
+        if (!isValidCatalogProviders(json.providers))
+            return false;
+        effectiveProviders = overlayProviders(json.providers);
+        effectiveVersion = typeof json.version === 'number' ? json.version : effectiveVersion;
+        try {
+            if (!fs.existsSync(CATALOG_CACHE_DIR))
+                fs.mkdirSync(CATALOG_CACHE_DIR, { recursive: true });
+            const cache = {
+                version: effectiveVersion,
+                providers: json.providers,
+                fetchedAt: new Date().toISOString(),
+            };
+            fs.writeFileSync(CATALOG_CACHE_FILE, JSON.stringify(cache, null, 2));
+        }
+        catch {
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getCatalogVersion() {
+    return effectiveVersion;
+}
+export function getProviders() {
+    return effectiveProviders;
+}
 export function getProvider(id) {
-    return PROVIDERS.find((p) => p.id === id);
+    return effectiveProviders.find((p) => p.id === id);
 }
 export function detectProviderFromUrl(baseUrl) {
     const url = baseUrl.toLowerCase();
-    for (const provider of PROVIDERS) {
+    for (const provider of effectiveProviders) {
         const providerHost = new URL(provider.baseUrl).hostname;
         if (url.includes(providerHost))
             return provider;
     }
-    for (const provider of PROVIDERS.filter((p) => p.isLocal && p.localPort)) {
+    for (const provider of effectiveProviders.filter((p) => p.isLocal && p.localPort)) {
         if (url.includes(`:${provider.localPort}`))
             return provider;
     }

package/dist/utils/platform-utils.js

@@ -51,16 +51,33 @@ export const BASH_DANGEROUS_PATTERNS = [
     /\brm\s+-rf\s+[\/~]/i,
     /\brm\s+-rf\s+\*/i,
     /\bdd\s+if=/i,
+    /\bdd\b[^\n]*\bof=\/dev\/sd/i,
     /\bmkfs\b/i,
     /\b:(){ :|:& };:/,
-    /\bchmod\s+-R\s+777\s+\//i,
+    /\bchmod\s+(-R\s+)?777\s+[\/~]/i,
     /\bsudo\s+rm/i,
     />\s*\/dev\/sd[a-z]/i,
+    /\b(curl|wget)\b[^|]*\|\s*(sudo\s+)?(ba|z)?sh\b/i,
+    /\bgit\s+push\b[^\n]*(?:^|\s)(?:--force|-f)\b[^\n]*\b(?:main|master|prod)\b/i,
+    /\bgit\s+push\b[^\n]*\b(?:main|master|prod)\b[^\n]*(?:^|\s)(?:--force|-f)\b/i,
     /\bshutdown\b/i,
     /\breboot\b/i,
     /\bhalt\b/i,
     /\bpoweroff\b/i,
 ];
+const CATASTROPHIC_RM_TARGET = /^(\/|~\/?|\*|\.\/?|\.\.\/?|\/\*|~\/\*)$/;
+function isCatastrophicRm(command) {
+    const m = command.match(/\brm\b((?:\s+-{1,2}[A-Za-z-]+)*)\s+(\S+)/i);
+    if (!m)
+        return false;
+    const flags = (m[1] ?? '').toLowerCase();
+    const target = m[2] ?? '';
+    const hasRecursive = /-{1,2}\w*r/.test(flags) || flags.includes('recursive');
+    const hasForce = /-{1,2}\w*f/.test(flags) || flags.includes('force');
+    if (!hasRecursive || !hasForce)
+        return false;
+    return CATASTROPHIC_RM_TARGET.test(target);
+}
 export const POWERSHELL_DANGEROUS_PATTERNS = [
     /Remove-Item\s+.*-Recurse\s+.*-Force\s+[A-Z]:\\/i,
     /ri\s+.*-r\s+.*-fo\s+[A-Z]:\\/i,
@@ -79,6 +96,8 @@ export const POWERSHELL_DANGEROUS_PATTERNS = [
     /for\s*\(\s*;\s*;\s*\)\s*\{.*Start-Process/i,
 ];
 export function isDangerousBashCommand(command) {
+    if (isCatastrophicRm(command))
+        return true;
     return BASH_DANGEROUS_PATTERNS.some(pattern => pattern.test(command));
 }
 export function isDangerousPowerShellCommand(command) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orquesta-cli",
-  "version": "0.2.106",
+  "version": "0.2.108",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",

package/dist/core/git-auto-updater.d.ts

@@ -1,58 +0,0 @@
-export type UpdateStatus = {
-    type: 'checking';
-} | {
-    type: 'no_update';
-} | {
-    type: 'first_run';
-    step: number;
-    totalSteps: number;
-    message: string;
-} | {
-    type: 'updating';
-    step: number;
-    totalSteps: number;
-    message: string;
-} | {
-    type: 'complete';
-    needsRestart: boolean;
-    message: string;
-} | {
-    type: 'error';
-    message: string;
-} | {
-    type: 'skipped';
-    reason: string;
-};
-export type StatusCallback = (status: UpdateStatus) => void;
-export declare class GitAutoUpdater {
-    private repoUrl;
-    private repoDir;
-    private commitFile;
-    private enabled;
-    private onStatus;
-    constructor(options?: {
-        repoUrl?: string;
-        enabled?: boolean;
-        onStatus?: StatusCallback;
-    });
-    setStatusCallback(callback: StatusCallback): void;
-    private emitStatus;
-    run(options?: {
-        noUpdate?: boolean;
-    }): Promise<boolean>;
-    private runBinaryMode;
-    private getRemoteCommit;
-    private getSavedCommit;
-    private saveCommit;
-    private updateBinary;
-    private initialSetup;
-    private pullAndUpdate;
-    private freshClone;
-    private rebuildAndLink;
-    private copyBinariesInternal;
-    private ensurePathConfigured;
-    private unlinkNpm;
-    private cleanupRepo;
-}
-export default GitAutoUpdater;
-//# sourceMappingURL=git-auto-updater.d.ts.map

package/dist/core/git-auto-updater.js

@@ -1,374 +0,0 @@
-import { spawn } from 'child_process';
-import fs, { createReadStream, createWriteStream } from 'fs';
-import { rm, copyFile, chmod } from 'fs/promises';
-import { pipeline } from 'stream/promises';
-import path from 'path';
-import os from 'os';
-import zlib from 'zlib';
-import { logger } from '../utils/logger.js';
-function isRunningAsBinary() {
-    const execPath = process.execPath;
-    const isNodeRuntime = execPath.includes('node') || execPath.includes('nodejs');
-    return !isNodeRuntime;
-}
-function execAsync(command, options = {}) {
-    return new Promise((resolve, reject) => {
-        const [cmd, ...args] = command.split(' ');
-        const child = spawn(cmd, args, {
-            cwd: options.cwd,
-            shell: true,
-            stdio: 'pipe',
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout?.on('data', (data) => {
-            stdout += data.toString();
-        });
-        child.stderr?.on('data', (data) => {
-            stderr += data.toString();
-        });
-        child.on('close', (code) => {
-            if (code === 0) {
-                resolve({ stdout, stderr });
-            }
-            else {
-                const error = new Error(`Command failed: ${command}`);
-                error.stdout = stdout;
-                error.stderr = stderr;
-                error.code = code;
-                reject(error);
-            }
-        });
-        child.on('error', (err) => {
-            reject(err);
-        });
-    });
-}
-export class GitAutoUpdater {
-    repoUrl = 'https://github.com/A2G-Dev-Space/Local-CLI.git';
-    repoDir;
-    commitFile;
-    enabled = true;
-    onStatus = null;
-    constructor(options) {
-        this.repoDir = path.join(os.homedir(), '.local-cli', 'repo');
-        this.commitFile = path.join(os.homedir(), '.local-cli', 'current-commit');
-        if (options?.repoUrl) {
-            this.repoUrl = options.repoUrl;
-        }
-        if (options?.enabled !== undefined) {
-            this.enabled = options.enabled;
-        }
-        if (options?.onStatus) {
-            this.onStatus = options.onStatus;
-        }
-    }
-    setStatusCallback(callback) {
-        this.onStatus = callback;
-    }
-    emitStatus(status) {
-        if (this.onStatus) {
-            this.onStatus(status);
-        }
-    }
-    async run(options = {}) {
-        logger.enter('GitAutoUpdater.run', {
-            noUpdate: options.noUpdate,
-            enabled: this.enabled,
-            repoDir: this.repoDir
-        });
-        if (options.noUpdate || !this.enabled) {
-            logger.flow('Git auto-update disabled - skipping');
-            this.emitStatus({ type: 'skipped', reason: 'disabled' });
-            return false;
-        }
-        this.emitStatus({ type: 'checking' });
-        try {
-            if (isRunningAsBinary() && fs.existsSync(this.repoDir)) {
-                logger.flow('Cleaning up leftover repo from previous version');
-                await this.cleanupRepo();
-            }
-            if (isRunningAsBinary()) {
-                return await this.runBinaryMode();
-            }
-            logger.flow('Checking repository directory');
-            if (!fs.existsSync(this.repoDir)) {
-                logger.flow('First run detected - need initial setup');
-                return await this.initialSetup();
-            }
-            else {
-                return await this.pullAndUpdate();
-            }
-        }
-        catch (error) {
-            logger.error('Git auto-update failed', error);
-            this.emitStatus({ type: 'error', message: 'Auto-update failed, continuing with current version' });
-        }
-        return false;
-    }
-    async runBinaryMode() {
-        logger.flow('Running in binary mode - using ls-remote for update check');
-        try {
-            const remoteCommit = await this.getRemoteCommit();
-            if (!remoteCommit) {
-                logger.error('Failed to get remote commit');
-                this.emitStatus({ type: 'error', message: 'Failed to check for updates' });
-                return false;
-            }
-            const savedCommit = this.getSavedCommit();
-            logger.debug('Version check', { remote: remoteCommit.slice(0, 7), saved: savedCommit?.slice(0, 7) || 'none' });
-            if (savedCommit === remoteCommit) {
-                logger.flow('Already up to date');
-                this.emitStatus({ type: 'no_update' });
-                return false;
-            }
-            logger.flow('Update available, starting update process');
-            return await this.updateBinary(remoteCommit);
-        }
-        catch (error) {
-            logger.error('Binary mode update failed', error);
-            this.emitStatus({ type: 'error', message: 'Update check failed' });
-            return false;
-        }
-    }
-    async getRemoteCommit() {
-        try {
-            const result = await execAsync(`git ls-remote ${this.repoUrl} refs/heads/main`);
-            const match = result.stdout.match(/^([a-f0-9]+)/);
-            return match && match[1] ? match[1] : null;
-        }
-        catch (error) {
-            logger.error('Failed to get remote commit via ls-remote', error);
-            return null;
-        }
-    }
-    getSavedCommit() {
-        try {
-            if (fs.existsSync(this.commitFile)) {
-                return fs.readFileSync(this.commitFile, 'utf-8').trim();
-            }
-        }
-        catch (error) {
-            logger.debug('Failed to read saved commit: ' + (error instanceof Error ? error.message : String(error)));
-        }
-        return null;
-    }
-    saveCommit(commit) {
-        try {
-            const dir = path.dirname(this.commitFile);
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
-            }
-            fs.writeFileSync(this.commitFile, commit);
-            logger.debug('Saved commit hash: ' + commit.slice(0, 7));
-        }
-        catch (error) {
-            logger.debug('Failed to save commit: ' + (error instanceof Error ? error.message : String(error)));
-        }
-    }
-    async updateBinary(remoteCommit) {
-        const totalSteps = 3;
-        const isFirstRun = !this.getSavedCommit();
-        try {
-            const statusType = isFirstRun ? 'first_run' : 'updating';
-            this.emitStatus({ type: statusType, step: 1, totalSteps, message: 'Downloading update...' });
-            const parentDir = path.dirname(this.repoDir);
-            if (!fs.existsSync(parentDir)) {
-                fs.mkdirSync(parentDir, { recursive: true });
-            }
-            await execAsync(`git clone --depth 1 ${this.repoUrl} ${this.repoDir}`);
-            this.emitStatus({ type: statusType, step: 2, totalSteps, message: 'Installing update...' });
-            const success = await this.copyBinariesInternal();
-            if (!success) {
-                return false;
-            }
-            this.emitStatus({ type: statusType, step: 3, totalSteps, message: 'Finalizing...' });
-            await this.cleanupRepo();
-            this.saveCommit(remoteCommit);
-            const shell = process.env['SHELL'] || '/bin/bash';
-            const rcFile = shell.includes('zsh') ? '~/.zshrc' : '~/.bashrc';
-            const restartMsg = isFirstRun
-                ? `Setup complete! Run: source ${rcFile} && lcli`
-                : 'Update complete! Please restart.';
-            this.emitStatus({ type: 'complete', needsRestart: true, message: restartMsg });
-            return true;
-        }
-        catch (error) {
-            logger.error('Binary update failed', error);
-            await this.cleanupRepo();
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            this.emitStatus({ type: 'error', message: `Update failed: ${message}` });
-            return false;
-        }
-    }
-    async initialSetup() {
-        logger.enter('initialSetup', {
-            repoDir: this.repoDir,
-            repoUrl: this.repoUrl
-        });
-        const totalSteps = 4;
-        try {
-            this.emitStatus({ type: 'first_run', step: 1, totalSteps, message: 'Cloning repository...' });
-            const parentDir = path.dirname(this.repoDir);
-            if (!fs.existsSync(parentDir)) {
-                fs.mkdirSync(parentDir, { recursive: true });
-            }
-            await execAsync(`git clone ${this.repoUrl} ${this.repoDir}`);
-            this.emitStatus({ type: 'first_run', step: 2, totalSteps, message: 'Installing dependencies...' });
-            await execAsync('npm install', { cwd: this.repoDir });
-            this.emitStatus({ type: 'first_run', step: 3, totalSteps, message: 'Building project...' });
-            await execAsync('npm run build', { cwd: this.repoDir });
-            this.emitStatus({ type: 'first_run', step: 4, totalSteps, message: 'Creating global link...' });
-            await execAsync('npm link', { cwd: this.repoDir });
-            this.emitStatus({ type: 'complete', needsRestart: true, message: 'Setup complete! Please restart.' });
-            return true;
-        }
-        catch (error) {
-            logger.error('Initial setup failed', error);
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            this.emitStatus({ type: 'error', message: `Setup failed: ${message}` });
-            return false;
-        }
-    }
-    async pullAndUpdate() {
-        logger.debug('Checking for updates', { repoDir: this.repoDir });
-        try {
-            await execAsync('git fetch origin main', { cwd: this.repoDir });
-            const currentResult = await execAsync('git rev-parse HEAD', { cwd: this.repoDir });
-            const latestResult = await execAsync('git rev-parse origin/main', { cwd: this.repoDir });
-            const currentCommit = currentResult.stdout.trim();
-            const latestCommit = latestResult.stdout.trim();
-            if (currentCommit === latestCommit) {
-                logger.debug('Already up to date, no rebuild needed');
-                this.emitStatus({ type: 'no_update' });
-                return false;
-            }
-            logger.debug('Resetting to latest commit...', { from: currentCommit.slice(0, 7), to: latestCommit.slice(0, 7) });
-            await execAsync('git reset --hard origin/main', { cwd: this.repoDir });
-            return await this.rebuildAndLink();
-        }
-        catch (error) {
-            logger.error('Pull/reset failed, attempting fresh clone', error);
-            return await this.freshClone();
-        }
-    }
-    async freshClone() {
-        logger.flow('Performing fresh clone');
-        try {
-            this.emitStatus({ type: 'updating', step: 1, totalSteps: 4, message: 'Removing old repository...' });
-            await rm(this.repoDir, { recursive: true, force: true });
-            return await this.initialSetup();
-        }
-        catch (error) {
-            logger.error('Fresh clone failed', error);
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            this.emitStatus({ type: 'error', message: `Fresh clone failed: ${message}` });
-            return false;
-        }
-    }
-    async rebuildAndLink() {
-        const totalSteps = 3;
-        try {
-            this.emitStatus({ type: 'updating', step: 1, totalSteps, message: 'Updating dependencies...' });
-            await execAsync('npm install', { cwd: this.repoDir });
-            this.emitStatus({ type: 'updating', step: 2, totalSteps, message: 'Building project...' });
-            await execAsync('npm run build', { cwd: this.repoDir });
-            this.emitStatus({ type: 'updating', step: 3, totalSteps, message: 'Updating global link...' });
-            await execAsync('npm link', { cwd: this.repoDir });
-            this.emitStatus({ type: 'complete', needsRestart: true, message: 'Update complete! Please restart.' });
-            return true;
-        }
-        catch (buildError) {
-            logger.error('Build/link failed', buildError);
-            const message = buildError instanceof Error ? buildError.message : 'Unknown error';
-            this.emitStatus({ type: 'error', message: `Build failed: ${message}` });
-            return false;
-        }
-    }
-    async copyBinariesInternal() {
-        try {
-            const repoBinDir = path.join(this.repoDir, 'bin');
-            const installDir = path.join(os.homedir(), '.local', 'bin');
-            const lcliGzSrc = path.join(repoBinDir, 'lcli.gz');
-            const yogaSrc = path.join(repoBinDir, 'yoga.wasm');
-            const lcliDest = path.join(installDir, 'lcli');
-            const yogaDest = path.join(installDir, 'yoga.wasm');
-            if (!fs.existsSync(lcliGzSrc)) {
-                this.emitStatus({ type: 'error', message: 'Binary not found in repository (bin/lcli.gz)' });
-                return false;
-            }
-            if (!fs.existsSync(installDir)) {
-                fs.mkdirSync(installDir, { recursive: true });
-            }
-            await rm(lcliDest, { force: true });
-            await pipeline(createReadStream(lcliGzSrc), zlib.createGunzip(), createWriteStream(lcliDest));
-            await chmod(lcliDest, 0o755);
-            if (fs.existsSync(yogaSrc)) {
-                await copyFile(yogaSrc, yogaDest);
-            }
-            await this.ensurePathConfigured(installDir);
-            await this.unlinkNpm();
-            logger.debug('Binaries copied successfully');
-            return true;
-        }
-        catch (error) {
-            logger.error('Copy binaries internal failed', error);
-            return false;
-        }
-    }
-    async ensurePathConfigured(binDir) {
-        const pathExport = `export PATH="${binDir}:$PATH"`;
-        const marker = '# local-cli binary';
-        const shell = process.env['SHELL'] || '/bin/bash';
-        let rcFile;
-        if (shell.includes('zsh')) {
-            rcFile = path.join(os.homedir(), '.zshrc');
-        }
-        else {
-            rcFile = path.join(os.homedir(), '.bashrc');
-        }
-        try {
-            let content = '';
-            if (fs.existsSync(rcFile)) {
-                content = fs.readFileSync(rcFile, 'utf-8');
-            }
-            if (content.includes(marker)) {
-                logger.debug('PATH already configured (marker found)');
-                return;
-            }
-            const currentPath = process.env['PATH'] || '';
-            if (currentPath.split(':').includes(binDir)) {
-                logger.debug('PATH already contains binDir, adding marker for future reference');
-                fs.appendFileSync(rcFile, `\n${marker}\n# PATH already configured elsewhere\n`);
-                return;
-            }
-            const addition = `\n${marker}\n${pathExport}\n`;
-            fs.appendFileSync(rcFile, addition);
-            logger.debug('PATH configuration added to ' + rcFile);
-        }
-        catch (error) {
-            logger.debug('Failed to configure PATH: ' + (error instanceof Error ? error.message : String(error)));
-        }
-    }
-    async unlinkNpm() {
-        try {
-            await execAsync('npm unlink -g local-cli');
-        }
-        catch (error) {
-        }
-    }
-    async cleanupRepo() {
-        try {
-            if (fs.existsSync(this.repoDir)) {
-                logger.debug('Cleaning up repo directory to prevent source code exposure');
-                await rm(this.repoDir, { recursive: true, force: true });
-                logger.debug('Repo directory removed successfully');
-            }
-        }
-        catch (error) {
-            logger.debug('Failed to cleanup repo: ' + (error instanceof Error ? error.message : String(error)));
-        }
-    }
-}
-export default GitAutoUpdater;
-//# sourceMappingURL=git-auto-updater.js.map