import { exec } from 'node:child_process';
import { promisify } from 'node:util';

const execPromise = promisify(exec);

async function runShellCommand() {
  try {
    const { stdout, stderr } = await execPromise('ls -lah /usr/local/bin');
    
    console.log('=== STDOUT ===');
    console.log(stdout);
    
    if (stderr) {
      console.error('=== STDERR ===');
      console.error(stderr);
    }
  } catch (error) {
    const execError = error as { code: number; stdout: string; stderr: string };
    console.error('Помилка виконання команди:');
    console.error('Exit Code:', execError.code);
    console.error('STDERR:', execError.stderr);
  }
}

runShellCommand();

exec(
  command: string,
  options?: {
    cwd?: string;              // Робоча директорія
    env?: object;              // Змінні оточення
    shell?: string;            // Shell для виконання (default: '/bin/sh' або 'cmd.exe')
    timeout?: number;          // Таймаут у мілісекундах
    maxBuffer?: number;        // Максимальний розмір буфера (default: 1 МБ)
    encoding?: string;         // Кодування виводу (default: 'utf8')
    killSignal?: string;       // Сигнал для завершення процесу (default: 'SIGTERM')
  },
  callback?: (error, stdout, stderr) => void
): ChildProcess

import { exec } from 'node:child_process';
import { promisify } from 'node:util';

const execPromise = promisify(exec);

async function complexShellCommand() {
  try {
    // Використовуємо pipe для з'єднання команд
    const { stdout } = await execPromise(
      'cat package.json | grep "version" | head -n 1'
    );
    
    console.log('Версія з package.json:', stdout.trim());
    // Виведе: "version": "1.0.0",
  } catch (error) {
    console.error('Помилка:', error);
  }
}

async function countLogFiles() {
  try {
    // Використовуємо wildcard для підрахунку файлів
    const { stdout } = await execPromise('ls -1 logs/*.log 2>/dev/null | wc -l');
    
    const count = parseInt(stdout.trim(), 10);
    console.log(`Знайдено ${count} лог-файлів`);
  } catch (error) {
    console.error('Помилка:', error);
  }
}

complexShellCommand();
countLogFiles();

import { exec } from 'node:child_process';
import { promisify } from 'node:util';

const execPromise = promisify(exec);

async function largeOutput() {
  try {
    // ❌ Помилка: вивід перевищує 1 МБ
    await execPromise('find /usr -type f');
  } catch (error) {
    console.error(error); // Error: maxBuffer exceeded
  }
  
  try {
    // ✅ Збільшуємо буфер до 10 МБ
    const { stdout } = await execPromise('find /usr -type f', {
      maxBuffer: 10 * 1024 * 1024,
    });
    
    const lines = stdout.split('\n').length;
    console.log(`Знайдено ${lines} файлів`);
  } catch (error) {
    console.error('Помилка:', error);
  }
}

largeOutput();

import { execSync } from 'node:child_process';

try {
  const output = execSync('git rev-parse --short HEAD', {
    encoding: 'utf-8',
    cwd: '/path/to/repo',
  });
  
  console.log('Поточний git commit:', output.trim());
} catch (error) {
  console.error('Помилка отримання git commit:', error);
}

import { spawn } from 'node:child_process';

// Запускаємо команду 'ls -lah /usr/local'
const child = spawn('ls', ['-lah', '/usr/local']);

// child.stdout — це Readable Stream
child.stdout.on('data', (data: Buffer) => {
  console.log('[STDOUT]:', data.toString());
});

// child.stderr — потік для помилок
child.stderr.on('data', (data: Buffer) => {
  console.error('[STDERR]:', data.toString());
});

// Подія завершення процесу
child.on('close', (code: number, signal: string | null) => {
  console.log(`Процес завершено з кодом ${code}`);
  
  if (signal) {
    console.log(`Процес убито сигналом: ${signal}`);
  }
});

// Подія помилки запуску
child.on('error', (error: Error) => {
  console.error('Помилка запуску процесу:', error.message);
});

import { spawn } from 'node:child_process';

// Запускаємо Python-скрипт, що читає з stdin
const python = spawn('python3', ['-c', `
import sys
for line in sys.stdin:
    print(f"Python отримав: {line.strip()}")
    sys.stdout.flush()
`]);

// python.stdin — Writable Stream
python.stdin.write('Перше повідомлення\n');
python.stdin.write('Друге повідомлення\n');
python.stdin.write('Третє повідомлення\n');

// Закриваємо stdin (надсилаємо EOF)
python.stdin.end();

python.stdout.on('data', (data: Buffer) => {
  console.log('[Python STDOUT]:', data.toString());
});

python.on('close', (code) => {
  console.log(`Python завершився з кодом ${code}`);
});

import { spawn } from 'node:child_process';

// ✅ З shell: дозволяє використовувати pipes
const child = spawn('ls -lah | grep node | wc -l', {
  shell: true,
});

child.stdout.on('data', (data: Buffer) => {
  console.log('Кількість файлів з "node":', data.toString().trim());
});

// Альтернатива: явно вказати shell
const child2 = spawn('bash', [
  '-c',
  'cat package.json | jq .version'
]);

import { execFile } from 'node:child_process';
import { promisify } from 'node:util';

const execFilePromise = promisify(execFile);

async function runExecutable() {
  try {
    // Запускаємо виконуваний файл напряму
    const { stdout, stderr } = await execFilePromise('/usr/bin/git', [
      'log',
      '--oneline',
      '-n',
      '5',
    ]);
    
    console.log('Останні 5 git commits:');
    console.log(stdout);
  } catch (error) {
    console.error('Помилка:', error);
  }
}

runExecutable();

import { spawn } from 'node:child_process';

function runCommandWithErrorHandling(command: string, args: string[]) {
  const child = spawn(command, args);
  
  let stdout = '';
  let stderr = '';
  
  child.stdout.on('data', (data) => {
    stdout += data.toString();
  });
  
  child.stderr.on('data', (data) => {
    stderr += data.toString();
  });
  
  child.on('close', (code, signal) => {
    if (code === 0) {
      console.log('✓ Команда виконана успішно');
      console.log(stdout);
    } else if (signal) {
      console.error(`✗ Процес убито сигналом: ${signal}`);
    } else {
      console.error(`✗ Команда завершилась з помилкою (exit code ${code})`);
      console.error('STDERR:', stderr);
      
      // Інтерпретація типових exit codes
      switch (code) {
        case 1:
          console.error('Загальна помилка виконання');
          break;
        case 126:
          console.error('Команда знайдена, але не може бути виконана');
          break;
        case 127:
          console.error('Команда не знайдена');
          break;
        case 130:
          console.error('Процес перервано (Ctrl+C)');
          break;
        default:
          console.error('Невідома помилка');
      }
    }
  });
  
  child.on('error', (error) => {
    console.error('✗ Помилка запуску процесу:', error.message);
    
    if (error.message.includes('ENOENT')) {
      console.error('Програма не знайдена. Перевірте PATH.');
    }
  });
}

// Приклад: команда, що не існує
runCommandWithErrorHandling('nonexistent-command', ['arg1']);

// Приклад: команда з помилкою виконання
runCommandWithErrorHandling('ls', ['/nonexistent-directory']);

import { spawn } from 'node:child_process';

function runWithTimeout(
  command: string,
  args: string[],
  timeoutMs: number
): Promise<string> {
  return new Promise((resolve, reject) => {
    const child = spawn(command, args);
    let stdout = '';
    let timedOut = false;
    
    // Встановлюємо таймаут
    const timeout = setTimeout(() => {
      timedOut = true;
      child.kill('SIGTERM'); // Спроба graceful shutdown
      
      // Якщо через 5 секунд процес не завершився — kill -9
      setTimeout(() => {
        if (!child.killed) {
          child.kill('SIGKILL');
        }
      }, 5000);
    }, timeoutMs);
    
    child.stdout.on('data', (data) => {
      stdout += data.toString();
    });
    
    child.on('close', (code) => {
      clearTimeout(timeout);
      
      if (timedOut) {
        reject(new Error(`Процес перевищив таймаут ${timeoutMs}мс`));
      } else if (code === 0) {
        resolve(stdout);
      } else {
        reject(new Error(`Exit code ${code}`));
      }
    });
    
    child.on('error', (error) => {
      clearTimeout(timeout);
      reject(error);
    });
  });
}

// Використання
runWithTimeout('sleep', ['10'], 2000) // Таймаут 2 секунди
  .then((output) => console.log('Вивід:', output))
  .catch((error) => console.error('Помилка:', error.message));
  
// Вивід: Помилка: Процес перевищив таймаут 2000мс

// worker.ts
process.on('message', (message: any) => {
  console.log('[Worker] Отримано повідомлення:', message);
  
  if (message.task === 'compute') {
    const result = fibonacci(message.n);
    
    // Відправляємо результат назад у батьківський процес
    process.send?.({
      task: 'compute',
      result,
      workerId: process.pid,
    });
  }
});

function fibonacci(n: number): number {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

console.log(`[Worker ${process.pid}] Готовий до роботи`);

// Повідомляємо батьківський процес про готовність
process.send?.({ status: 'ready', pid: process.pid });

// main.ts
import { fork } from 'node:child_process';
import { resolve } from 'node:path';

const worker = fork(resolve(__dirname, 'worker.ts'));

worker.on('message', (message: any) => {
  console.log('[Main] Отримано від Worker:', message);
  
  if (message.status === 'ready') {
    console.log(`[Main] Worker ${message.pid} готовий`);
    
    // Відправляємо завдання у Worker
    worker.send({
      task: 'compute',
      n: 42,
    });
  } else if (message.task === 'compute') {
    console.log(`[Main] Результат обчислення: ${message.result}`);
    
    // Завершуємо Worker після отримання результату
    worker.disconnect();
  }
});

worker.on('exit', (code, signal) => {
  console.log(`[Main] Worker завершено з кодом ${code}`);
});

console.log('[Main] Запуск Worker процесу...');

import { readFile } from 'node:fs/promises';

interface Task {
  taskId: string;
  filePath: string;
}

process.on('message', async (task: Task) => {
  try {
    console.log(`[Worker ${process.pid}] Обробка файлу: ${task.filePath}`);
    
    // Читаємо файл
    const content = await readFile(task.filePath, 'utf-8');
    
    // Обробляємо дані (підрахунок слів)
    const words = content.split(/\s+/).filter((w) => w.length > 0);
    const wordCount = words.length;
    const uniqueWords = new Set(words.map((w) => w.toLowerCase()));
    
    // Відправляємо результат
    process.send?.({
      taskId: task.taskId,
      filePath: task.filePath,
      wordCount,
      uniqueWordCount: uniqueWords.size,
      pid: process.pid,
    });
  } catch (error) {
    process.send?.({
      taskId: task.taskId,
      error: (error as Error).message,
      pid: process.pid,
    });
  }
});

process.send?.({ status: 'ready', pid: process.pid });

import { fork, ChildProcess } from 'node:child_process';
import { readdir } from 'node:fs/promises';
import { resolve, join } from 'node:path';
import { cpus } from 'node:os';

interface Task {
  taskId: string;
  filePath: string;
}

class ProcessPool {
  private workers: ChildProcess[] = [];
  private freeWorkers: ChildProcess[] = [];
  private taskQueue: Task[] = [];
  private results = new Map<string, any>();
  
  constructor(
    private workerScript: string,
    private poolSize: number = cpus().length
  ) {}
  
  async initialize(): Promise<void> {
    console.log(`Створення пулу з ${this.poolSize} процесів...`);
    
    const workerPromises = Array.from({ length: this.poolSize }, (_, i) => {
      return new Promise<void>((resolve) => {
        const worker = fork(resolve(__dirname, this.workerScript));
        
        worker.on('message', (message: any) => {
          if (message.status === 'ready') {
            console.log(`Worker ${message.pid} готовий`);
            this.workers.push(worker);
            this.freeWorkers.push(worker);
            resolve();
          } else {
            this.handleWorkerResult(worker, message);
          }
        });
        
        worker.on('exit', (code) => {
          console.log(`Worker завершено з кодом ${code}`);
          this.removeWorker(worker);
        });
      });
    });
    
    await Promise.all(workerPromises);
    console.log('Пул процесів готовий\n');
  }
  
  private handleWorkerResult(worker: ChildProcess, result: any): void {
    this.results.set(result.taskId, result);
    
    if (result.error) {
      console.error(`✗ Помилка обробки ${result.taskId}: ${result.error}`);
    } else {
      console.log(`✓ Оброблено ${result.filePath} (${result.wordCount} слів)`);
    }
    
    // Повертаємо Worker у пул вільних
    this.freeWorkers.push(worker);
    
    // Обробляємо наступну задачу з черги
    this.processNextTask();
  }
  
  private processNextTask(): void {
    if (this.taskQueue.length === 0 || this.freeWorkers.length === 0) {
      return;
    }
    
    const task = this.taskQueue.shift()!;
    const worker = this.freeWorkers.shift()!;
    
    worker.send(task);
  }
  
  private removeWorker(worker: ChildProcess): void {
    const idx = this.workers.indexOf(worker);
    if (idx !== -1) this.workers.splice(idx, 1);
    
    const freeIdx = this.freeWorkers.indexOf(worker);
    if (freeIdx !== -1) this.freeWorkers.splice(freeIdx, 1);
  }
  
  public async submitTask(task: Task): Promise<void> {
    this.taskQueue.push(task);
    this.processNextTask();
  }
  
  public async waitForCompletion(): Promise<Map<string, any>> {
    return new Promise((resolve) => {
      const checkInterval = setInterval(() => {
        const allTasksProcessed = 
          this.taskQueue.length === 0 &&
          this.freeWorkers.length === this.workers.length;
        
        if (allTasksProcessed) {
          clearInterval(checkInterval);
          resolve(this.results);
        }
      }, 100);
    });
  }
  
  public async terminate(): Promise<void> {
    console.log('\nЗавершення всіх Worker процесів...');
    
    for (const worker of this.workers) {
      worker.disconnect();
      worker.kill();
    }
    
    this.workers = [];
    this.freeWorkers = [];
  }
}

// Використання
async function main() {
  const pool = new ProcessPool('processor-worker.ts', 4);
  await pool.initialize();
  
  // Отримуємо список файлів для обробки
  const files = await readdir('./data');
  const textFiles = files.filter((f) => f.endsWith('.txt'));
  
  console.log(`Відправка ${textFiles.length} файлів на обробку...\n`);
  const startTime = Date.now();
  
  // Відправляємо задачі у пул
  for (const file of textFiles) {
    await pool.submitTask({
      taskId: file,
      filePath: join('./data', file),
    });
  }
  
  // Чекаємо завершення всіх задач
  const results = await pool.waitForCompletion();
  
  const duration = Date.now() - startTime;
  
  // Статистика
  const successful = Array.from(results.values()).filter((r) => !r.error);
  const totalWords = successful.reduce((sum, r) => sum + r.wordCount, 0);
  
  console.log('\n=== Результати ===');
  console.log(`Оброблено файлів: ${successful.length}`);
  console.log(`Загальна кількість слів: ${totalWords}`);
  console.log(`Час виконання: ${(duration / 1000).toFixed(2)}с`);
  
  await pool.terminate();
}

main().catch(console.error);

import sys
import json
import numpy as np
from sklearn.linear_model import LinearRegression

def train_and_predict(data_points):
    """Навчання лінійної регресії та передбачення"""
    X = np.array([[x] for x, _ in data_points])
    y = np.array([y for _, y in data_points])
    
    model = LinearRegression()
    model.fit(X, y)
    
    # Передбачення для наступних 5 точок
    future_X = np.array([[max(X)[0] + i] for i in range(1, 6)])
    predictions = model.predict(future_X)
    
    return {
        'slope': float(model.coef_[0]),
        'intercept': float(model.intercept_),
        'predictions': predictions.tolist()
    }

if __name__ == '__main__':
    # Читаємо JSON з stdin
    input_data = json.loads(sys.stdin.read())
    
    result = train_and_predict(input_data['dataPoints'])
    
    # Виводимо JSON у stdout
    print(json.dumps(result))
    sys.stdout.flush()

import { spawn } from 'node:child_process';

interface DataPoint {
  x: number;
  y: number;
}

interface MLResult {
  slope: number;
  intercept: number;
  predictions: number[];
}

function runPythonML(dataPoints: DataPoint[]): Promise<MLResult> {
  return new Promise((resolve, reject) => {
    const python = spawn('python3', ['ml_model.py']);
    
    let stdout = '';
    let stderr = '';
    
    python.stdout.on('data', (data) => {
      stdout += data.toString();
    });
    
    python.stderr.on('data', (data) => {
      stderr += data.toString();
    });
    
    python.on('close', (code) => {
      if (code === 0) {
        try {
          const result = JSON.parse(stdout);
          resolve(result);
        } catch (error) {
          reject(new Error(`Помилка парсингу JSON: ${error}`));
        }
      } else {
        reject(new Error(`Python завершився з кодом ${code}\nSTDERR: ${stderr}`));
      }
    });
    
    python.on('error', (error) => {
      reject(new Error(`Помилка запуску Python: ${error.message}`));
    });
    
    // Відправляємо дані у Python через stdin
    python.stdin.write(JSON.stringify({ dataPoints }));
    python.stdin.end();
  });
}

// Використання
async function main() {
  const trainingData: DataPoint[] = [
    { x: 1, y: 2.1 },
    { x: 2, y: 3.9 },
    { x: 3, y: 6.2 },
    { x: 4, y: 7.8 },
    { x: 5, y: 10.1 },
    { x: 6, y: 11.9 },
  ];
  
  console.log('Навчання ML-моделі через Python...');
  
  try {
    const result = await runPythonML(trainingData);
    
    console.log('\n=== Результати моделі ===');
    console.log(`Нахил (slope): ${result.slope.toFixed(4)}`);
    console.log(`Зміщення (intercept): ${result.intercept.toFixed(4)}`);
    console.log('\nПередбачення для наступних 5 точок:');
    result.predictions.forEach((pred, i) => {
      console.log(`  x=${7 + i}: y ≈ ${pred.toFixed(2)}`);
    });
  } catch (error) {
    console.error('Помилка:', (error as Error).message);
  }
}

main();

import { exec } from 'node:child_process';

// ❌ КРИТИЧНА ВРАЗЛИВІСТЬ: user input у exec()
app.get('/api/file', (req, res) => {
  const filename = req.query.filename; // "file.txt; rm -rf /"
  
  exec(`cat ${filename}`, (error, stdout) => {
    // Shell виконає ДВІ команди:
    // 1. cat file.txt
    // 2. rm -rf / (видалить всю файлову систему!)
    res.send(stdout);
  });
});

import { spawn } from 'node:child_process';
import { createWriteStream } from 'node:fs';

function convertVideo(
  inputPath: string,
  outputPath: string
): Promise<void> {
  return new Promise((resolve, reject) => {
    const ffmpeg = spawn('ffmpeg', [
      '-i', inputPath,
      '-c:v', 'libx264',
      '-crf', '23',
      '-c:a', 'aac',
      '-b:a', '128k',
      '-progress', 'pipe:2', // Progress у stderr
      outputPath,
    ]);
    
    ffmpeg.stderr.on('data', (data) => {
      const progress = data.toString();
      
      // Парсимо прогрес
      const timeMatch = progress.match(/time=(\d+):(\d+):(\d+\.\d+)/);
      if (timeMatch) {
        const [, hours, minutes, seconds] = timeMatch;
        const totalSeconds = 
          parseInt(hours) * 3600 +
          parseInt(minutes) * 60 +
          parseFloat(seconds);
        
        console.log(`Прогрес: ${totalSeconds.toFixed(1)}с`);
      }
    });
    
    ffmpeg.on('close', (code) => {
      if (code === 0) resolve();
      else reject(new Error(`ffmpeg exit code ${code}`));
    });
  });
}

// Використання
convertVideo('./input.mp4', './output.mp4')
  .then(() => console.log('Конвертація завершена'))
  .catch(console.error);

import { spawn } from 'node:child_process';

async function gitCommitAndPush(message: string): Promise<void> {
  // git add .
  await runGitCommand(['add', '.']);
  
  // git commit -m "message"
  await runGitCommand(['commit', '-m', message]);
  
  // git push origin main
  await runGitCommand(['push', 'origin', 'main']);
}

function runGitCommand(args: string[]): Promise<string> {
  return new Promise((resolve, reject) => {
    const git = spawn('git', args);
    let stdout = '';
    let stderr = '';
    
    git.stdout.on('data', (data) => {
      stdout += data.toString();
    });
    
    git.stderr.on('data', (data) => {
      stderr += data.toString();
    });
    
    git.on('close', (code) => {
      if (code === 0) {
        console.log(`✓ git ${args.join(' ')}`);
        resolve(stdout);
      } else {
        reject(new Error(`Git error: ${stderr}`));
      }
    });
  });
}

gitCommitAndPush('Add new feature')
  .then(() => console.log('Changes pushed successfully'))
  .catch(console.error);