Plugins¶

// commands/hello.js
module.exports = {
  name: 'hello',
  description: 'Comando de exemplo',

  // Opções do comando
  options: [
    {
      name: 'name',
      alias: 'n',
      type: 'string',
      description: 'Nome para saudação',
      default: 'World'
    }
  ],

  // Handler do comando
  async handler(options, context) {
    const { name } = options;
    const { logger, config } = context;

    logger.info(`Hello, ${name}!`);

    // Acessar configuração do plugin
    const apiKey = config.get('api_key');
    if (apiKey) {
      logger.debug('API key configurada');
    }

    return {
      success: true,
      message: `Hello, ${name}!`
    };
  }
};

// hooks/pre-start.js
module.exports = {
  name: 'pre-start',
  description: 'Executado antes de iniciar serviços',

  async handler(context) {
    const { logger, services, config } = context;

    logger.info('Executando verificações pré-inicialização...');

    // Verificar se serviços estão configurados corretamente
    for (const service of services) {
      if (!service.healthcheck) {
        logger.warn(`Serviço ${service.name} não possui healthcheck`);
      }
    }

    return {
      success: true
    };
  }
};

{
  // Logger configurado
  logger: {
    debug: (message) => {},
    info: (message) => {},
    warn: (message) => {},
    error: (message) => {}
  },

  // Configuração do plugin
  config: {
    get: (key) => {},
    set: (key, value) => {},
    has: (key) => {}
  },

  // Serviços do projeto
  services: [
    {
      name: 'api',
      image: 'myapp/api',
      ports: ['3000:3000'],
      // ...
    }
  ],

  // Utilitários Docker
  docker: {
    exec: (container, command) => {},
    logs: (container, options) => {},
    inspect: (container) => {}
  },

  // Sistema de arquivos
  fs: {
    readFile: (path) => {},
    writeFile: (path, content) => {},
    exists: (path) => {}
  },

  // HTTP client
  http: {
    get: (url, options) => {},
    post: (url, data, options) => {}
  }
}

// index.js
import path  from "path";

class MeuPlugin {
  constructor(context) {
    this.context = context;
    this.config = context.config;
    this.logger = context.logger;
  }

  // Inicialização do plugin
  async initialize() {
    this.logger.info('Inicializando Meu Plugin...');

    // Validar configuração
    if (!this.config.get('api_key')) {
      throw new Error('API key é obrigatória');
    }

    // Configurar recursos
    await this.setupResources();
  }

  // Configurar recursos
  async setupResources() {
    // Criar diretórios necessários
    const dataDir = path.join(process.cwd(), '.meu-plugin');
    if (!this.context.fs.exists(dataDir)) {
      await this.context.fs.mkdir(dataDir, { recursive: true });
    }
  }

  // Limpeza do plugin
  async cleanup() {
    this.logger.info('Limpando recursos do plugin...');
    // Limpeza de recursos
  }

  // Comando personalizado
  async executeCustomCommand(args) {
    this.logger.info('Executando comando personalizado...');

    // Lógica do comando
    const result = await this.processData(args);

    return {
      success: true,
      data: result
    };
  }

  // Processamento interno
  async processData(data) {
    // Implementar lógica específica
    return data;
  }
}

module.exports = MeuPlugin;

// commands/notify.js
module.exports = {
  name: 'notify',
  description: 'Enviar notificação para Slack',

  options: [
    {
      name: 'message',
      alias: 'm',
      type: 'string',
      description: 'Mensagem para enviar',
      required: true
    },
    {
      name: 'channel',
      alias: 'c',
      type: 'string',
      description: 'Canal do Slack'
    }
  ],

  async handler(options, context) {
    const { message, channel } = options;
    const { config, http, logger } = context;

    const webhookUrl = config.get('webhook_url');
    const defaultChannel = config.get('default_channel');

    try {
      await http.post(webhookUrl, {
        text: message,
        channel: channel || defaultChannel
      });

      logger.info('Notificação enviada com sucesso');
      return { success: true };
    } catch (error) {
      logger.error('Erro ao enviar notificação:', error.message);
      return { success: false, error: error.message };
    }
  }
};

// commands/backup.js
import tar  from "tar";
const fs = require('fs').promises;

module.exports = {
  name: 'backup',
  description: 'Criar backup customizado',

  async handler(options, context) {
    const { logger, docker, config } = context;

    const backupPath = config.get('backup_path') || './backups';
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
    const backupFile = `${backupPath}/backup-${timestamp}.tar.gz`;

    try {
      // Criar diretório de backup
      await fs.mkdir(backupPath, { recursive: true });

      // Parar serviços temporariamente
      logger.info('Parando serviços...');
      await docker.exec('docker-pilot', ['stop', '--all']);

      // Criar backup dos volumes
      logger.info('Criando backup...');
      await tar.create({
        gzip: true,
        file: backupFile
      }, ['./data', './config']);

      // Reiniciar serviços
      logger.info('Reiniciando serviços...');
      await docker.exec('docker-pilot', ['start', '--all']);

      logger.info(`Backup criado: ${backupFile}`);
      return { success: true, backup_file: backupFile };

    } catch (error) {
      logger.error('Erro no backup:', error.message);
      return { success: false, error: error.message };
    }
  }
};