tsdocker/ts/tsdocker.cli.ts

import * as plugins from './tsdocker.plugins.js';
import * as paths from './tsdocker.paths.js';

// modules
import * as ConfigModule from './tsdocker.config.js';
import * as DockerModule from './tsdocker.docker.js';

import { logger, ora } from './tsdocker.logging.js';
import { TsDockerManager } from './classes.tsdockermanager.js';

const tsdockerCli = new plugins.smartcli.Smartcli();

export let run = () => {
  // Default command: run tests in container (legacy behavior)
  tsdockerCli.standardCommand().subscribe(async argvArg => {
    const configArg = await ConfigModule.run().then(DockerModule.run);
    if (configArg.exitCode === 0) {
      logger.log('success', 'container ended all right!');
    } else {
      logger.log('error', `container ended with error! Exit Code is ${configArg.exitCode}`);
      process.exit(1);
    }
  });

  /**
   * Build all Dockerfiles in dependency order
   */
  tsdockerCli.addCommand('build').subscribe(async argvArg => {
    try {
      const config = await ConfigModule.run();
      const manager = new TsDockerManager(config);
      await manager.prepare();
      await manager.build();
      logger.log('success', 'Build completed successfully');
    } catch (err) {
      logger.log('error', `Build failed: ${(err as Error).message}`);
      process.exit(1);
    }
  });

  /**
   * Push built images to configured registries
   */
  tsdockerCli.addCommand('push').subscribe(async argvArg => {
    try {
      const config = await ConfigModule.run();
      const manager = new TsDockerManager(config);
      await manager.prepare();

      // Login first
      await manager.login();

      // Build images first (if not already built)
      await manager.build();

      // Get registry from arguments if specified
      const registryArg = argvArg._[1]; // e.g., tsdocker push registry.gitlab.com
      const registries = registryArg ? [registryArg] : undefined;

      await manager.push(registries);
      logger.log('success', 'Push completed successfully');
    } catch (err) {
      logger.log('error', `Push failed: ${(err as Error).message}`);
      process.exit(1);
    }
  });

  /**
   * Pull images from a specified registry
   */
  tsdockerCli.addCommand('pull').subscribe(async argvArg => {
    try {
      const registryArg = argvArg._[1]; // e.g., tsdocker pull registry.gitlab.com
      if (!registryArg) {
        logger.log('error', 'Registry URL required. Usage: tsdocker pull <registry-url>');
        process.exit(1);
      }

      const config = await ConfigModule.run();
      const manager = new TsDockerManager(config);
      await manager.prepare();

      // Login first
      await manager.login();

      await manager.pull(registryArg);
      logger.log('success', 'Pull completed successfully');
    } catch (err) {
      logger.log('error', `Pull failed: ${(err as Error).message}`);
      process.exit(1);
    }
  });

  /**
   * Run container tests for all Dockerfiles
   */
  tsdockerCli.addCommand('test').subscribe(async argvArg => {
    try {
      const config = await ConfigModule.run();
      const manager = new TsDockerManager(config);
      await manager.prepare();

      // Build images first
      await manager.build();

      // Run tests
      await manager.test();
      logger.log('success', 'Tests completed successfully');
    } catch (err) {
      logger.log('error', `Tests failed: ${(err as Error).message}`);
      process.exit(1);
    }
  });

  /**
   * Login to configured registries
   */
  tsdockerCli.addCommand('login').subscribe(async argvArg => {
    try {
      const config = await ConfigModule.run();
      const manager = new TsDockerManager(config);
      await manager.prepare();
      await manager.login();
      logger.log('success', 'Login completed successfully');
    } catch (err) {
      logger.log('error', `Login failed: ${(err as Error).message}`);
      process.exit(1);
    }
  });

  /**
   * List discovered Dockerfiles and their dependencies
   */
  tsdockerCli.addCommand('list').subscribe(async argvArg => {
    try {
      const config = await ConfigModule.run();
      const manager = new TsDockerManager(config);
      await manager.prepare();
      await manager.list();
    } catch (err) {
      logger.log('error', `List failed: ${(err as Error).message}`);
      process.exit(1);
    }
  });

  /**
   * this command is executed inside docker and meant for use from outside docker
   */
  tsdockerCli.addCommand('runinside').subscribe(async argvArg => {
    logger.log('ok', 'Allright. We are now in Docker!');
    ora.text('now trying to run your specified command');
    const configArg = await ConfigModule.run();
    const smartshellInstance = new plugins.smartshell.Smartshell({
      executor: 'bash'
    });
    ora.stop();
    await smartshellInstance.exec(configArg.command).then(response => {
      if (response.exitCode !== 0) {
        process.exit(1);
      }
    });
  });

  tsdockerCli.addCommand('clean').subscribe(async argvArg => {
    ora.text('cleaning up docker env...');
    if (argvArg.all) {
      const smartshellInstance = new plugins.smartshell.Smartshell({
        executor: 'bash'
      });
      ora.text('killing any running docker containers...');
      await smartshellInstance.exec(`docker kill $(docker ps -q)`);

      ora.text('removing stopped containers...');
      await smartshellInstance.exec(`docker rm $(docker ps -a -q)`);

      ora.text('removing images...');
      await smartshellInstance.exec(`docker rmi -f $(docker images -q -f dangling=true)`);

      ora.text('removing all other images...');
      await smartshellInstance.exec(`docker rmi $(docker images -a -q)`);

      ora.text('removing all volumes...');
      await smartshellInstance.exec(`docker volume rm $(docker volume ls -f dangling=true -q)`);
    }
    ora.finishSuccess('docker environment now is clean!');
  });

  tsdockerCli.addCommand('vscode').subscribe(async argvArg => {
    const smartshellInstance = new plugins.smartshell.Smartshell({
      executor: 'bash'
    });
    logger.log('ok', `Starting vscode in cwd ${paths.cwd}`);
    await smartshellInstance.execAndWaitForLine(
      `docker run -p 127.0.0.1:8443:8443 -v "${
        paths.cwd
      }:/home/coder/project" registry.gitlab.com/hosttoday/ht-docker-vscode --allow-http --no-auth`,
      /Connected to shared process/
    );
    await plugins.smartopen.openUrl('testing-vscode.git.zone:8443');
  });

  tsdockerCli.startParse();
};