@runium/plugin-docker 0.0.1 → 0.0.3

package/index.js

@@ -0,0 +1 @@
+import{DockerTask as o}from"./tasks/docker-task.js";import{DockerComposeTask as e}from"./tasks/docker-compose-task.js";import{getDockerTaskProjectSchema as r}from"./validation/docker-task-project-schema.js";import{getDockerComposeTaskProjectSchema as c}from"./validation/docker-compose-task-project-schema.js";function p(){return{name:"docker",project:{tasks:{docker:o,"docker-compose":e},validationSchema:{tasks:{Docker_DockerTask:r(),Docker_DockerComposeTask:c()}}}}}export{p as default};

package/package.json

@@ -1,38 +1,18 @@
 {
   "name": "@runium/plugin-docker",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Runium plugin for Docker support",
   "author": "TheBeastApp",
   "license": "MIT",
   "type": "module",
-  "main": "dist/index.js",
-  "scripts": {
-    "build": "rimraf ./lib && node build.js",
-    "build:tsc": "rimraf ./lib && tsc",
-    "lint": "eslint ./src --ext .ts",
-    "lint:fix": "eslint ./src --ext .ts --fix",
-    "format": "prettier --write \"src/**/*.ts\""
-  },
   "keywords": [
     "runium",
     "runium-plugin",
     "docker"
   ],
-  "devDependencies": {
-    "@runium/types-plugin": "^0.0.6",
-    "@typescript-eslint/eslint-plugin": "^7.0.0",
-    "@typescript-eslint/parser": "^7.0.0",
-    "esbuild": "^0.25.11",
-    "eslint": "^8.56.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-prettier": "^5.1.3",
-    "prettier": "^3.2.5",
-    "rimraf": "^6.1.0",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.3.3",
-    "vite": "^7.1.12"
-  },
+  "module": "./index.js",
+  "main": "./index.js",
   "dependencies": {
     "yaml": "^2.8.2"
   }
-}
+}

package/tasks/docker-compose-task.js

@@ -0,0 +1 @@
+import{spawn as a}from"node:child_process";import{stringify as p}from"yaml";import{DockerTaskBase as c}from"./docker-task-base.js";import{isDockerInstalled as m}from"../utils/is-docker-installed.js";import{isDockerRunning as d}from"../utils/is-docker-running.js";import{pullImage as g}from"../utils/pull-image.js";const{TaskStatus:s}=runium.enum;class C extends c{constructor(r){super(r);this.options=r;this.projectName=`runium-docker-compose-${Date.now()}`,this.composeFile=`docker-compose-${this.projectName}.yml`}projectName;composeFile;version="3.8";correctExitCodes=[130];generateComposeYaml(){const r={version:this.version,services:{}};for(const[o,e]of Object.entries(this.options.services)){const t={image:e.image};e.containerName&&(t.container_name=e.containerName),e.command&&(t.command=e.command),e.ports&&e.ports.length>0&&(t.ports=e.ports),e.volumes&&e.volumes.length>0&&(t.volumes=e.volumes),e.environment&&Object.keys(e.environment).length>0&&(t.environment=e.environment),e.networks&&e.networks.length>0&&(t.networks=e.networks),e.dependsOn&&e.dependsOn.length>0&&(t.depends_on=e.dependsOn),e.restart&&(t.restart=e.restart),e.user&&(t.user=e.user),e.workdir&&(t.working_dir=e.workdir),e.entrypoint&&(t.entrypoint=e.entrypoint),e.privileged&&(t.privileged=e.privileged),e.expose&&e.expose.length>0&&(t.expose=e.expose),e.healthcheck&&(t.healthcheck=e.healthcheck),r.services[o]=t}return this.options.networks&&Object.keys(this.options.networks).length>0&&(r.networks=this.options.networks),this.options.volumes&&Object.keys(this.options.volumes).length>0&&(r.volumes=this.options.volumes),p(r)}async pullAllImages(){const r=Object.values(this.options.services).map(e=>e.image),o=[...new Set(r)];for(const e of o)this.updateState({reason:`pull image: ${e}`}),await g(e,{onStdErr:this.onStdErrData.bind(this)})}prepareDockerComposeArgs(r){const o=["compose"];return o.push("-p",this.projectName),o.push("-f",runium.storage.getPath(["docker",this.composeFile])),o.push(r),o}async start(){if(this.canStart()){if(this.updateState({status:s.STARTING,iteration:this.state.iteration+1,pid:-1,exitCode:void 0,error:void 0,reason:void 0}),!await m()){this.onError(new Error("Docker is not installed"));return}if(!await d()){this.onError(new Error("Docker is not running"));return}try{const r=this.generateComposeYaml();await runium.storage.write(["docker",this.composeFile],r),await this.initLogStreams(),await this.pullAllImages();const o=this.prepareDockerComposeArgs("up");this.process=a("docker",o,{stdio:["ignore","pipe","pipe"]}),this.addProcessListeners(),this.setTTLTimer(),this.updateState({status:s.STARTED,pid:this.process.pid,reason:void 0})}catch(r){this.onError(r)}}}async stop(r=""){if(this.canStop()){this.updateState({status:s.STOPPING,reason:r});try{const o=this.prepareDockerComposeArgs("down");await new Promise((e,t)=>{const n=a("docker",o);n.on("exit",i=>{i===0?e():t(new Error(`Docker compose down exited with code ${i}`))}),n.on("error",t)})}catch(o){this.onError(o)}}}}export{C as DockerComposeTask};

package/tasks/docker-task-base.js

@@ -0,0 +1 @@
+import{createWriteStream as o}from"node:fs";import{mkdir as a}from"node:fs/promises";import{dirname as n,resolve as u}from"node:path";import{setTimeout as l}from"node:timers";const d=-1,m=50,{TaskStatus:s,TaskEvent:i}=runium.enum;class P extends runium.class.RuniumTask{constructor(t){super(t);this.options=t;this.setMaxListeners(m)}correctExitCodes=[];state={status:s.IDLE,timestamp:Date.now(),iteration:0,pid:-1};process=null;stdoutStream=null;stderrStream=null;ttlTimer=null;getState(){return{...this.state}}getOptions(){return{...this.options}}canStart(){const{status:t}=this.state;return t!==s.STARTED&&t!==s.STARTING&&t!==s.STOPPING}canStop(){const{status:t}=this.state;return t===s.STARTED||t===s.STARTING}async restart(){await this.stop("restart"),await this.start()}async initLogStreams(){const{stdout:t=null,stderr:e=null}=this.options.log||{};if(t){const r=u(t);await a(n(r),{recursive:!0}),this.stdoutStream=o(t,{flags:"w"})}if(e){const r=u(e);await a(n(r),{recursive:!0}),this.stderrStream=o(e,{flags:"w"})}}setTTLTimer(){const{ttl:t}=this.options;t&&this.process&&(this.ttlTimer=l(()=>{this.stop("ttl")},t))}addProcessListeners(){this.process&&(this.process.stdout?.on("data",t=>this.onStdOutData(t)),this.process.stderr?.on("data",t=>this.onStdErrData(t)),this.process.on("exit",t=>this.onExit(t)),this.process.on("error",t=>this.onError(t)))}onStdOutData(t){const e=t.toString();this.emit(i.STDOUT,e),this.stdoutStream&&this.stdoutStream.write(e)}onStdErrData(t){const e=t.toString();this.emit(i.STDERR,e),this.stderrStream&&this.stderrStream.write(e)}onExit(t){const e=t!==null&&!this.correctExitCodes.includes(t)?t:d;this.updateState({status:e===0?s.COMPLETED:e===d?s.STOPPED:s.FAILED,exitCode:e}),this.cleanup()}onError(t){const e=t?.code??null;this.updateState({status:e===null?s.STOPPED:s.FAILED,reason:t.message||(e??"")}),this.cleanup()}updateState(t){const e={...this.state,...t,timestamp:Date.now()};this.state=Object.fromEntries(Object.entries(e).filter(([r,c])=>c!==void 0)),this.emit(i.STATE_CHANGE,this.getState()),this.emit(this.state.status,this.getState())}cleanup(){this.ttlTimer&&(clearTimeout(this.ttlTimer),this.ttlTimer=null),this.process&&(this.process.removeAllListeners(),this.process.stdout?.removeAllListeners(),this.process.stderr?.removeAllListeners(),this.process=null),this.stdoutStream&&(this.stdoutStream.end(),this.stdoutStream=null),this.stderrStream&&(this.stderrStream.end(),this.stderrStream=null)}}export{P as DockerTaskBase,d as SILENT_EXIT_CODE};

package/tasks/docker-task.js

@@ -0,0 +1 @@
+import{spawn as n}from"node:child_process";import{DockerTaskBase as a}from"./docker-task-base.js";import{isDockerInstalled as p}from"../utils/is-docker-installed.js";import{isDockerRunning as h}from"../utils/is-docker-running.js";import{pullImage as c}from"../utils/pull-image.js";const{TaskStatus:o}=runium.enum;class T extends a{constructor(t){super(t);this.options=t;this.options.containerName??=`runium-${this.options.image.replaceAll("/","-").replaceAll(":","-")}-${Date.now()}`}correctExitCodes=[137];prepareDockerArgs(){const t=["run"];return this.options.autoRemove!==!1&&t.push("--rm"),this.options.containerName&&t.push("--name",this.options.containerName),this.options.ports&&this.options.ports.forEach(s=>{t.push("-p",s)}),this.options.volumes&&this.options.volumes.forEach(s=>{t.push("-v",s)}),this.options.env&&Object.entries(this.options.env).forEach(([s,i])=>{t.push("-e",`${s}=${i}`)}),this.options.network&&t.push("--network",this.options.network),this.options.user&&t.push("--user",this.options.user),this.options.workdir&&t.push("--workdir",this.options.workdir),this.options.entrypoint&&t.push("--entrypoint",this.options.entrypoint),this.options.privileged&&t.push("--privileged"),t.push(this.options.image),this.options.command&&t.push(this.options.command),this.options.arguments&&t.push(...this.options.arguments),t}async start(){if(this.canStart()){if(this.updateState({status:o.STARTING,iteration:this.state.iteration+1,pid:-1,containerName:void 0,exitCode:void 0,error:void 0,reason:void 0}),!await p()){this.onError(new Error("Docker is not installed"));return}if(!await h()){this.onError(new Error("Docker is not running"));return}try{await this.initLogStreams(),this.updateState({reason:`pull image: ${this.options.image}`}),await c(this.options.image,{onStdErr:this.onStdErrData.bind(this)});const t=this.prepareDockerArgs();this.process=n("docker",t,{stdio:["ignore","pipe","pipe"]}),this.addProcessListeners(),this.setTTLTimer(),this.updateState({status:o.STARTED,containerName:this.options.containerName,pid:this.process.pid,reason:void 0})}catch(t){this.onError(t)}}}async stop(t=""){if(this.canStop()){this.updateState({status:o.STOPPING,reason:t});try{await new Promise((s,i)=>{const e=n("docker",["stop",this.options.containerName]);e.on("exit",r=>{r===0?s():i(new Error(`Docker stop exited with code ${r}`))}),e.on("error",i)})}catch(s){this.onError(s)}finally{await new Promise(s=>{this.process?.kill("SIGTERM"),this.process?.on("exit",()=>{s()})})}}}}export{T as DockerTask};

package/utils/exec-async.js

@@ -0,0 +1 @@
+import{exec as o}from"node:child_process";import{promisify as r}from"node:util";const c=r(o);export{c as execAsync};

package/utils/is-docker-installed.js

@@ -0,0 +1 @@
+import{execAsync as e}from"./exec-async.js";async function o(){try{return await e("docker --version"),!0}catch{return!1}}export{o as isDockerInstalled};

package/utils/is-docker-running.js

@@ -0,0 +1 @@
+import{execAsync as r}from"./exec-async.js";async function n(){try{return await r("docker info"),!0}catch{return!1}}export{n as isDockerRunning};

package/utils/pull-image.js

@@ -0,0 +1 @@
+import{exec as d}from"node:child_process";async function l(n,e={}){return new Promise((u,o)=>{const r=d(`docker pull ${n}`);r.stdout&&e.onStdOut&&r.stdout.on("data",t=>{e.onStdOut(t.toString())}),r.stderr&&e.onStdErr&&r.stderr.on("data",t=>{e.onStdErr(t.toString())}),r.on("exit",t=>{t===0?u():o({code:t,message:t===null?"":`docker pull exited with code ${t}`})}),r.on("error",t=>{o({message:t.message,code:-1})})})}export{l as pullImage};

package/validation/docker-compose-task-project-schema.js

@@ -0,0 +1 @@
+function r(){return{type:"docker-compose",options:{type:"object",properties:{services:{type:"object",patternProperties:{"^[a-zA-Z0-9_-]+$":{type:"object",properties:{image:{type:"string"},containerName:{type:"string"},command:{type:"string"},ports:{type:"array",items:{type:"string"}},volumes:{type:"array",items:{type:"string"}},environment:{$ref:"#/$defs/Runium_Env"},networks:{type:"array",items:{type:"string"}},dependsOn:{type:"array",items:{type:"string"}},restart:{type:"string",enum:["no","always","on-failure","unless-stopped"]},user:{type:"string"},workdir:{type:"string"},entrypoint:{type:"string"},privileged:{type:"boolean"},expose:{type:"array",items:{type:"string"}},healthcheck:{type:"object",properties:{test:{oneOf:[{type:"string"},{type:"array",items:{type:"string"}}]},interval:{type:"string"},timeout:{type:"string"},retries:{type:"number"},start_period:{type:"string"}},required:["test"],additionalProperties:!1}},required:["image"],additionalProperties:!1}},additionalProperties:!1},networks:{type:"object",patternProperties:{"^[a-zA-Z0-9_-]+$":{type:"object"}},additionalProperties:!1},volumes:{type:"object",patternProperties:{"^[a-zA-Z0-9_-]+$":{type:"object"}},additionalProperties:!1},ttl:{type:"number"},log:{$ref:"#/$defs/Runium_TaskLog"}},required:["services"],additionalProperties:!1}}}export{r as getDockerComposeTaskProjectSchema};

package/validation/docker-task-project-schema.js

@@ -0,0 +1 @@
+function r(){return{type:"docker",options:{type:"object",properties:{image:{type:"string"},containerName:{type:"string"},command:{type:"string"},arguments:{type:"array",items:{type:"string"}},ports:{type:"array",items:{type:"string"}},volumes:{type:"array",items:{type:"string"}},env:{$ref:"#/$defs/Runium_Env"},network:{type:"string"},autoRemove:{type:"boolean"},user:{type:"string"},workdir:{type:"string"},entrypoint:{type:"string"},privileged:{type:"boolean"},ttl:{type:"number"},log:{$ref:"#/$defs/Runium_TaskLog"}},required:["image"],additionalProperties:!1}}}export{r as getDockerTaskProjectSchema};

package/.eslintrc.json

@@ -1,19 +0,0 @@
-{
-  "parser": "@typescript-eslint/parser",
-  "extends": [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended",
-    "plugin:prettier/recommended"
-  ],
-  "parserOptions": {
-    "ecmaVersion": 2022,
-    "sourceType": "module"
-  },
-  "rules": {
-    "@typescript-eslint/no-explicit-any": "warn",
-    "@typescript-eslint/explicit-module-boundary-types": "off",
-    "@typescript-eslint/no-unused-vars": ["error", {
-      "argsIgnorePattern": "^(_)$"
-    }]
-  }
-}

package/.prettierrc.json

@@ -1,8 +0,0 @@
-{
-  "semi": true,
-  "trailingComma": "es5",
-  "singleQuote": true,
-  "printWidth": 80,
-  "tabWidth": 2,
-  "arrowParens": "avoid"
-}

package/build.js

@@ -1,95 +0,0 @@
-#!/usr/bin/env node
-
-import {
-  chmodSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-} from 'node:fs';
-import { resolve } from 'node:path';
-import { build } from 'esbuild';
-
-const buildConfig = {
-  entryPoints: ['src/**/*.ts'],
-  bundle: false,
-  platform: 'node',
-  target: 'esnext',
-  format: 'esm',
-  outdir: 'lib',
-  sourcemap: false,
-  minify: true,
-  treeShaking: false,
-  plugins: [],
-  metafile: true,
-  logLevel: 'info',
-};
-
-async function buildProject() {
-  try {
-    console.log('🔨 Building project with esbuild...');
-
-    const libDir = 'lib';
-    if (!existsSync(libDir)) {
-      mkdirSync(libDir, { recursive: true });
-    }
-
-    const result = await build(buildConfig);
-
-    if (process.platform !== 'win32') {
-      try {
-        chmodSync('lib/index.js', '755');
-        console.log('🔐 Made lib/index.js executable');
-      } catch (error) {
-        console.warn('⚠️  Could not make file executable:', error.message);
-      }
-    }
-
-    console.log('🔨 Processing package.json...');
-    await processPackageJson();
-
-    console.log('✅ Build completed successfully!');
-
-    // Print build stats if in development mode
-    if (result.metafile) {
-      console.log('\n📊 Build statistics:');
-      const outputs = result.metafile.outputs;
-      for (const [file, info] of Object.entries(outputs)) {
-        console.log(`  ${file}: ${(info.bytes / 1024).toFixed(2)} KB`);
-      }
-    }
-  } catch (error) {
-    console.error('❌ Build failed:', error);
-    process.exit(1);
-  }
-}
-
-async function processPackageJson() {
-  let originalPackageJson = readFileSync('./package.json', {
-    encoding: 'utf-8',
-  });
-
-  let packageJson = JSON.parse(originalPackageJson);
-  const { dependencies } = packageJson;
-
-  delete packageJson.dependencies;
-  delete packageJson.devDependencies;
-  delete packageJson.scripts;
-  delete packageJson.module;
-  delete packageJson.main;
-
-  console.log('✅ Processed package.json', packageJson);
-
-  packageJson = Object.assign(packageJson, {
-    module: './index.js',
-    main: './index.js',
-    dependencies,
-  });
-
-  writeFileSync(
-    resolve(import.meta.dirname, 'lib', 'package.json'),
-    JSON.stringify(packageJson, null, 2)
-  );
-}
-
-buildProject();

package/src/index.ts

@@ -1,23 +0,0 @@
-import { Plugin } from '@runium/types-plugin';
-import { DockerTask } from './tasks/docker-task.js';
-import { DockerComposeTask } from './tasks/docker-compose-task.js';
-import { getDockerTaskProjectSchema } from './validation/docker-task-project-schema.js';
-import { getDockerComposeTaskProjectSchema } from './validation/docker-compose-task-project-schema.js';
-
-export default function (): Plugin {
-  return {
-    name: 'docker',
-    project: {
-      tasks: {
-        docker: DockerTask,
-        'docker-compose': DockerComposeTask,
-      },
-      validationSchema: {
-        tasks: {
-          Docker_DockerTask: getDockerTaskProjectSchema(),
-          Docker_DockerComposeTask: getDockerComposeTaskProjectSchema(),
-        },
-      },
-    },
-  } as Plugin;
-}

package/src/tasks/docker-compose-task.ts

@@ -1,299 +0,0 @@
-import { spawn, SpawnOptionsWithoutStdio } from 'node:child_process';
-import { stringify } from 'yaml';
-import {
-  DockerTaskBase,
-  DockerTaskBaseOptions,
-  DockerTaskBaseState,
-} from './docker-task-base.js';
-import { isDockerInstalled } from '../utils/is-docker-installed.js';
-import { isDockerRunning } from '../utils/is-docker-running.js';
-import { pullImage } from '../utils/pull-image.js';
-
-/**
- * Docker service configuration
- */
-export interface DockerComposeService {
-  image: string;
-  containerName?: string;
-  command?: string;
-  ports?: string[];
-  volumes?: string[];
-  environment?: { [key: string]: string | number | boolean };
-  networks?: string[];
-  dependsOn?: string[];
-  restart?: 'no' | 'always' | 'on-failure' | 'unless-stopped';
-  user?: string;
-  workdir?: string;
-  entrypoint?: string | string[];
-  privileged?: boolean;
-  expose?: string[];
-  healthcheck?: {
-    test: string | string[];
-    interval?: string;
-    timeout?: string;
-    retries?: number;
-    start_period?: string;
-  };
-}
-
-/**
- * Docker compose task options
- */
-export interface DockerComposeTaskOptions extends DockerTaskBaseOptions {
-  services: { [serviceName: string]: DockerComposeService };
-  networks?: { [networkName: string]: unknown };
-  volumes?: { [volumeName: string]: unknown };
-}
-
-/**
- * Docker compose task state
- */
-export type DockerComposeTaskState = DockerTaskBaseState;
-
-interface DockerComposeYaml {
-  version: string;
-  services: Record<string, Record<string, unknown>>;
-  networks?: Record<string, unknown>;
-  volumes?: Record<string, unknown>;
-}
-
-const { TaskStatus } = runium.enum;
-
-/**
- * Docker compose task class
- */
-export class DockerComposeTask extends DockerTaskBase<
-  DockerComposeTaskOptions,
-  DockerComposeTaskState
-> {
-  protected readonly projectName: string;
-  protected readonly composeFile: string;
-  protected readonly version: string = '3.8';
-
-  // 128 + SIGTERM when stopping docker-compose
-  protected correctExitCodes: number[] = [130];
-
-  constructor(protected readonly options: DockerComposeTaskOptions) {
-    super(options);
-
-    // TODO: unique project name
-    this.projectName = `runium-docker-compose-${Date.now()}`;
-    this.composeFile = `docker-compose-${this.projectName}.yml`;
-  }
-
-  /**
-   * Generate docker-compose YAML content
-   */
-  private generateComposeYaml(): string {
-    const compose: DockerComposeYaml = {
-      version: this.version,
-      services: {},
-    };
-
-    // services
-    for (const [serviceName, service] of Object.entries(
-      this.options.services
-    )) {
-      const serviceConfig: Record<string, unknown> = {
-        image: service.image,
-      };
-
-      if (service.containerName) {
-        serviceConfig.container_name = service.containerName;
-      }
-
-      if (service.command) {
-        serviceConfig.command = service.command;
-      }
-
-      if (service.ports && service.ports.length > 0) {
-        serviceConfig.ports = service.ports;
-      }
-
-      if (service.volumes && service.volumes.length > 0) {
-        serviceConfig.volumes = service.volumes;
-      }
-
-      if (service.environment && Object.keys(service.environment).length > 0) {
-        serviceConfig.environment = service.environment;
-      }
-
-      if (service.networks && service.networks.length > 0) {
-        serviceConfig.networks = service.networks;
-      }
-
-      if (service.dependsOn && service.dependsOn.length > 0) {
-        serviceConfig.depends_on = service.dependsOn;
-      }
-
-      if (service.restart) {
-        serviceConfig.restart = service.restart;
-      }
-
-      if (service.user) {
-        serviceConfig.user = service.user;
-      }
-
-      if (service.workdir) {
-        serviceConfig.working_dir = service.workdir;
-      }
-
-      if (service.entrypoint) {
-        serviceConfig.entrypoint = service.entrypoint;
-      }
-
-      if (service.privileged) {
-        serviceConfig.privileged = service.privileged;
-      }
-
-      if (service.expose && service.expose.length > 0) {
-        serviceConfig.expose = service.expose;
-      }
-
-      if (service.healthcheck) {
-        serviceConfig.healthcheck = service.healthcheck;
-      }
-
-      compose.services[serviceName] = serviceConfig;
-    }
-
-    // networks if specified
-    if (
-      this.options.networks &&
-      Object.keys(this.options.networks).length > 0
-    ) {
-      compose.networks = this.options.networks;
-    }
-
-    // volumes if specified
-    if (this.options.volumes && Object.keys(this.options.volumes).length > 0) {
-      compose.volumes = this.options.volumes;
-    }
-
-    // convert to YAML format using yaml package
-    return stringify(compose);
-  }
-
-  /**
-   * Pull all images for services
-   */
-  private async pullAllImages(): Promise<void> {
-    const images = Object.values(this.options.services).map(
-      service => service.image
-    );
-    const uniqueImages = [...new Set(images)];
-
-    for (const image of uniqueImages) {
-      this.updateState({
-        reason: `pull image: ${image}`,
-      });
-      await pullImage(image, {
-        onStdErr: this.onStdErrData.bind(this),
-      });
-    }
-  }
-
-  /**
-   * Prepare docker-compose command arguments
-   */
-  private prepareDockerComposeArgs(command: string): string[] {
-    const args: string[] = ['compose'];
-
-    args.push('-p', this.projectName);
-    args.push('-f', runium.storage.getPath(['docker', this.composeFile]));
-    args.push(command);
-
-    return args;
-  }
-
-  /**
-   * Start task
-   */
-  async start(): Promise<void> {
-    if (!this.canStart()) {
-      return;
-    }
-
-    this.updateState({
-      status: TaskStatus.STARTING,
-      iteration: this.state.iteration + 1,
-      pid: -1,
-      exitCode: undefined,
-      error: undefined,
-      reason: undefined,
-    });
-
-    if (!(await isDockerInstalled())) {
-      this.onError(new Error('Docker is not installed'));
-      return;
-    }
-
-    if (!(await isDockerRunning())) {
-      this.onError(new Error('Docker is not running'));
-      return;
-    }
-
-    try {
-      // generate docker-compose yaml file
-      const yamlContent = this.generateComposeYaml();
-      await runium.storage.write(['docker', this.composeFile], yamlContent);
-
-      await this.initLogStreams();
-
-      await this.pullAllImages();
-
-      // Start docker-compose
-      const args = this.prepareDockerComposeArgs('up');
-
-      this.process = spawn('docker', args, {
-        stdio: ['ignore', 'pipe', 'pipe'],
-      } as SpawnOptionsWithoutStdio);
-
-      this.addProcessListeners();
-
-      this.setTTLTimer();
-
-      this.updateState({
-        status: TaskStatus.STARTED,
-        pid: this.process!.pid,
-        reason: undefined,
-      });
-    } catch (error) {
-      this.onError(error as Error);
-    }
-  }
-
-  /**
-   * Stop task
-   * @param reason
-   */
-  async stop(reason: string = ''): Promise<void> {
-    if (!this.canStop()) {
-      return;
-    }
-
-    this.updateState({
-      status: TaskStatus.STOPPING,
-      reason,
-    });
-
-    try {
-      // stop docker-compose services
-      const args = this.prepareDockerComposeArgs('down');
-
-      await new Promise<void>((resolve, reject) => {
-        const stopProcess = spawn('docker', args);
-        stopProcess.on('exit', code => {
-          if (code === 0) {
-            resolve();
-          } else {
-            reject(new Error(`Docker compose down exited with code ${code}`));
-          }
-        });
-        stopProcess.on('error', reject);
-      });
-    } catch (error) {
-      this.onError(error as Error);
-    }
-  }
-}

package/src/tasks/docker-task-base.ts

@@ -1,257 +0,0 @@
-import { ChildProcessWithoutNullStreams } from 'node:child_process';
-import { createWriteStream, WriteStream } from 'node:fs';
-import { mkdir } from 'node:fs/promises';
-import { dirname, resolve } from 'node:path';
-import { setTimeout } from 'node:timers';
-import * as Runium from '@runium/types-plugin';
-
-export const SILENT_EXIT_CODE = -1;
-
-const MAX_LISTENERS_COUNT = 50;
-
-const { TaskStatus, TaskEvent } = runium.enum;
-
-/**
- * Docker task base options
- */
-export interface DockerTaskBaseOptions {
-  ttl?: number;
-  log?: {
-    stdout?: string | null;
-    stderr?: string | null;
-  };
-}
-
-/**
- * Docker task base state
- */
-export interface DockerTaskBaseState extends Runium.RuniumTaskState {
-  pid?: number;
-}
-
-/**
- * Docker task base class
- */
-export abstract class DockerTaskBase<
-  Options extends DockerTaskBaseOptions = DockerTaskBaseOptions,
-  State extends DockerTaskBaseState = DockerTaskBaseState,
-> extends runium.class.RuniumTask<Options, State> {
-  protected correctExitCodes: number[] = [];
-
-  protected state: State = {
-    status: TaskStatus.IDLE,
-    timestamp: Date.now(),
-    iteration: 0,
-    pid: -1,
-  } as State;
-
-  protected process: ChildProcessWithoutNullStreams | null = null;
-  protected stdoutStream: WriteStream | null = null;
-  protected stderrStream: WriteStream | null = null;
-  protected ttlTimer: NodeJS.Timeout | null = null;
-
-  constructor(protected readonly options: Options) {
-    super(options);
-    this.setMaxListeners(MAX_LISTENERS_COUNT);
-  }
-
-  /**
-   * Get task state
-   */
-  public getState(): State {
-    return { ...this.state };
-  }
-
-  /**
-   * Get task options
-   */
-  public getOptions(): Options {
-    return { ...this.options };
-  }
-
-  /**
-   * Check if task can start
-   */
-  protected canStart(): boolean {
-    const { status } = this.state;
-    return (
-      status !== TaskStatus.STARTED &&
-      status !== TaskStatus.STARTING &&
-      status !== TaskStatus.STOPPING
-    );
-  }
-
-  /**
-   * Check if task can stop
-   */
-  protected canStop(): boolean {
-    const { status } = this.state;
-    return status === TaskStatus.STARTED || status === TaskStatus.STARTING;
-  }
-
-  /**
-   * Start task
-   */
-  abstract start(): Promise<void>;
-
-  /**
-   * Stop task
-   * @param reason
-   */
-  abstract stop(reason: string): Promise<void>;
-
-  /**
-   * Restart task
-   */
-  async restart(): Promise<void> {
-    await this.stop('restart');
-    await this.start();
-  }
-
-  /**
-   * Initialize log streams
-   */
-  protected async initLogStreams(): Promise<void> {
-    const { stdout = null, stderr = null } = this.options.log || {};
-    if (stdout) {
-      const stdOutPath = resolve(stdout);
-      await mkdir(dirname(stdOutPath), { recursive: true });
-      this.stdoutStream = createWriteStream(stdout, {
-        flags: 'w',
-      });
-    }
-    if (stderr) {
-      const stdErrPath = resolve(stderr);
-      await mkdir(dirname(stdErrPath), { recursive: true });
-      this.stderrStream = createWriteStream(stderr, {
-        flags: 'w',
-      });
-    }
-  }
-
-  /**
-   * Set TTL timer
-   */
-  protected setTTLTimer(): void {
-    const { ttl } = this.options;
-    if (ttl && this.process) {
-      this.ttlTimer = setTimeout(() => {
-        this.stop('ttl');
-      }, ttl);
-    }
-  }
-
-  /**
-   * Add process listeners
-   */
-  protected addProcessListeners(): void {
-    if (!this.process) return;
-
-    this.process.stdout?.on('data', (data: Buffer) => this.onStdOutData(data));
-
-    this.process.stderr?.on('data', (data: Buffer) => this.onStdErrData(data));
-
-    this.process.on('exit', (code: number | null) => this.onExit(code));
-
-    this.process.on('error', (error: Error) => this.onError(error));
-  }
-
-  /**
-   * On standard output data
-   */
-  protected onStdOutData(data: Buffer): void {
-    const output = data.toString();
-    this.emit(TaskEvent.STDOUT, output);
-    if (this.stdoutStream) {
-      this.stdoutStream!.write(output);
-    }
-  }
-
-  /**
-   * On standard error data
-   */
-  protected onStdErrData(data: Buffer): void {
-    const output = data.toString();
-    this.emit(TaskEvent.STDERR, output);
-    if (this.stderrStream) {
-      this.stderrStream!.write(output);
-    }
-  }
-
-  /**
-   * On exit
-   * @param code
-   */
-  protected onExit(code: number | null): void {
-    const exitCode =
-      code !== null && !this.correctExitCodes.includes(code)
-        ? code
-        : SILENT_EXIT_CODE;
-
-    this.updateState({
-      status:
-        exitCode === 0
-          ? TaskStatus.COMPLETED
-          : exitCode === SILENT_EXIT_CODE
-            ? TaskStatus.STOPPED
-            : TaskStatus.FAILED,
-      exitCode,
-    } as State);
-
-    this.cleanup();
-  }
-
-  /**
-   * On error
-   */
-  protected onError(error: Error): void {
-    const code = ((error as { code?: string })?.code ?? null) as number | null;
-    this.updateState({
-      status: code === null ? TaskStatus.STOPPED : TaskStatus.FAILED,
-      reason: error.message || (code ?? ''),
-    } as State);
-
-    this.cleanup();
-  }
-
-  /**
-   * Update task state
-   */
-  protected updateState(state: Partial<State>): void {
-    const newState = { ...this.state, ...state, timestamp: Date.now() };
-    this.state = Object.fromEntries(
-      Object.entries(newState).filter(([_, value]) => {
-        return value !== undefined;
-      })
-    ) as unknown as State;
-    this.emit(TaskEvent.STATE_CHANGE, this.getState());
-    this.emit(this.state.status, this.getState());
-  }
-
-  /**
-   * Cleanup
-   */
-  protected cleanup(): void {
-    if (this.ttlTimer) {
-      clearTimeout(this.ttlTimer);
-      this.ttlTimer = null;
-    }
-
-    if (this.process) {
-      this.process.removeAllListeners();
-      this.process.stdout?.removeAllListeners();
-      this.process.stderr?.removeAllListeners();
-      this.process = null;
-    }
-
-    if (this.stdoutStream) {
-      this.stdoutStream.end();
-      this.stdoutStream = null;
-    }
-
-    if (this.stderrStream) {
-      this.stderrStream.end();
-      this.stderrStream = null;
-    }
-  }
-}

package/src/tasks/docker-task.ts

@@ -1,221 +0,0 @@
-import { spawn, SpawnOptionsWithoutStdio } from 'node:child_process';
-import {
-  DockerTaskBase,
-  DockerTaskBaseOptions,
-  DockerTaskBaseState,
-} from './docker-task-base.js';
-import { isDockerInstalled } from '../utils/is-docker-installed.js';
-import { isDockerRunning } from '../utils/is-docker-running.js';
-import { pullImage } from '../utils/pull-image.js';
-
-/**
- * Docker task options
- */
-export interface DockerTaskOptions extends DockerTaskBaseOptions {
-  // TODO: support more options
-  //  env-file, expose, healthchecking, mount
-  image: string;
-  containerName?: string;
-  command?: string;
-  arguments?: string[];
-  ports?: string[];
-  volumes?: string[];
-  env?: { [key: string]: string | number | boolean };
-  network?: string;
-  autoRemove?: boolean;
-  user?: string;
-  workdir?: string;
-  entrypoint?: string;
-  privileged?: boolean;
-}
-
-/**
- * Docker task state
- */
-export interface DockerTaskState extends DockerTaskBaseState {
-  containerName?: string;
-}
-
-const { TaskStatus } = runium.enum;
-
-/**
- * Docker task class
- */
-export class DockerTask extends DockerTaskBase<
-  DockerTaskOptions,
-  DockerTaskState
-> {
-  // 128 + SIGKILL when stopping docker container
-  protected correctExitCodes: number[] = [137];
-
-  constructor(protected readonly options: DockerTaskOptions) {
-    super(options);
-
-    this.options.containerName ??= `runium-${this.options.image.replaceAll('/', '-').replaceAll(':', '-')}-${Date.now()}`;
-  }
-
-  /**
-   * Prepare docker run command arguments
-   */
-  private prepareDockerArgs(): string[] {
-    const args: string[] = ['run'];
-
-    if (this.options.autoRemove !== false) {
-      args.push('--rm');
-    }
-
-    if (this.options.containerName) {
-      args.push('--name', this.options.containerName);
-    }
-
-    if (this.options.ports) {
-      this.options.ports.forEach(port => {
-        args.push('-p', port);
-      });
-    }
-
-    if (this.options.volumes) {
-      this.options.volumes.forEach(volume => {
-        args.push('-v', volume);
-      });
-    }
-
-    if (this.options.env) {
-      Object.entries(this.options.env).forEach(([key, value]) => {
-        args.push('-e', `${key}=${value}`);
-      });
-    }
-
-    if (this.options.network) {
-      args.push('--network', this.options.network);
-    }
-
-    if (this.options.user) {
-      args.push('--user', this.options.user);
-    }
-
-    if (this.options.workdir) {
-      args.push('--workdir', this.options.workdir);
-    }
-
-    if (this.options.entrypoint) {
-      args.push('--entrypoint', this.options.entrypoint);
-    }
-
-    if (this.options.privileged) {
-      args.push('--privileged');
-    }
-
-    args.push(this.options.image);
-
-    if (this.options.command) {
-      args.push(this.options.command);
-    }
-
-    if (this.options.arguments) {
-      args.push(...this.options.arguments);
-    }
-
-    return args;
-  }
-
-  /**
-   * Start task
-   */
-  async start(): Promise<void> {
-    if (!this.canStart()) {
-      return;
-    }
-
-    this.updateState({
-      status: TaskStatus.STARTING,
-      iteration: this.state.iteration + 1,
-      pid: -1,
-      containerName: undefined,
-      exitCode: undefined,
-      error: undefined,
-      reason: undefined,
-    });
-
-    if (!(await isDockerInstalled())) {
-      this.onError(new Error('Docker is not installed'));
-      return;
-    }
-
-    if (!(await isDockerRunning())) {
-      this.onError(new Error('Docker is not running'));
-      return;
-    }
-
-    try {
-      await this.initLogStreams();
-
-      this.updateState({
-        reason: `pull image: ${this.options.image}`,
-      });
-      await pullImage(this.options.image, {
-        onStdErr: this.onStdErrData.bind(this),
-      });
-
-      const args = this.prepareDockerArgs();
-
-      this.process = spawn('docker', args, {
-        stdio: ['ignore', 'pipe', 'pipe'],
-      } as SpawnOptionsWithoutStdio);
-
-      this.addProcessListeners();
-
-      this.setTTLTimer();
-
-      this.updateState({
-        status: TaskStatus.STARTED,
-        containerName: this.options.containerName,
-        pid: this.process!.pid,
-        reason: undefined,
-      });
-    } catch (error) {
-      this.onError(error as Error);
-    }
-  }
-
-  /**
-   * Stop task
-   * @param reason
-   */
-  async stop(reason: string = ''): Promise<void> {
-    if (!this.canStop()) {
-      return;
-    }
-
-    this.updateState({
-      status: TaskStatus.STOPPING,
-      reason,
-    });
-
-    try {
-      await new Promise<void>((resolve, reject) => {
-        const stopProcess = spawn('docker', [
-          'stop',
-          this.options.containerName!,
-        ]);
-        stopProcess.on('exit', code => {
-          if (code === 0) {
-            resolve();
-          } else {
-            reject(new Error(`Docker stop exited with code ${code}`));
-          }
-        });
-        stopProcess.on('error', reject);
-      });
-    } catch (error) {
-      this.onError(error as Error);
-    } finally {
-      await new Promise<void>(resolve => {
-        this.process?.kill('SIGTERM' as NodeJS.Signals);
-        this.process?.on('exit', () => {
-          resolve();
-        });
-      });
-    }
-  }
-}

package/src/utils/exec-async.ts

@@ -1,4 +0,0 @@
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-
-export const execAsync = promisify(exec);

package/src/utils/is-docker-installed.ts

@@ -1,13 +0,0 @@
-import { execAsync } from './exec-async.js';
-
-/**
- * Check if Docker is installed
- */
-export async function isDockerInstalled(): Promise<boolean> {
-  try {
-    await execAsync('docker --version');
-    return true;
-  } catch {
-    return false;
-  }
-}

package/src/utils/is-docker-running.ts

@@ -1,13 +0,0 @@
-import { execAsync } from './exec-async.js';
-
-/**
- * Check if Docker daemon is running
- */
-export async function isDockerRunning(): Promise<boolean> {
-  try {
-    await execAsync('docker info');
-    return true;
-  } catch {
-    return false;
-  }
-}

package/src/utils/pull-image.ts

@@ -1,47 +0,0 @@
-import { exec } from 'node:child_process';
-
-interface PullImageOptions {
-  onStdOut?: (output: Buffer) => void;
-  onStdErr?: (output: Buffer) => void;
-}
-
-/**
- * Pull a Docker image
- * @param imageName
- * @param options
- */
-export async function pullImage(
-  imageName: string,
-  options: PullImageOptions = {}
-): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const child = exec(`docker pull ${imageName}`);
-
-    if (child.stdout && options.onStdOut) {
-      child.stdout.on('data', data => {
-        options.onStdOut!(data.toString());
-      });
-    }
-
-    if (child.stderr && options.onStdErr) {
-      child.stderr.on('data', data => {
-        options.onStdErr!(data.toString());
-      });
-    }
-
-    child.on('exit', (code: number | null) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject({
-          code,
-          message: code === null ? '' : `docker pull exited with code ${code}`,
-        });
-      }
-    });
-
-    child.on('error', (error: Error) => {
-      reject({ message: error.message, code: -1 });
-    });
-  });
-}

package/src/validation/docker-compose-task-project-schema.ts

@@ -1,137 +0,0 @@
-import { ProjectSchemaExtensionTask } from '@runium/types-plugin';
-
-export function getDockerComposeTaskProjectSchema(): ProjectSchemaExtensionTask {
-  return {
-    type: 'docker-compose',
-    options: {
-      type: 'object',
-      properties: {
-        services: {
-          type: 'object',
-          patternProperties: {
-            '^[a-zA-Z0-9_-]+$': {
-              type: 'object',
-              properties: {
-                image: {
-                  type: 'string',
-                },
-                containerName: {
-                  type: 'string',
-                },
-                command: {
-                  type: 'string',
-                },
-                ports: {
-                  type: 'array',
-                  items: {
-                    type: 'string',
-                  },
-                },
-                volumes: {
-                  type: 'array',
-                  items: {
-                    type: 'string',
-                  },
-                },
-                environment: {
-                  $ref: '#/$defs/Runium_Env',
-                },
-                networks: {
-                  type: 'array',
-                  items: {
-                    type: 'string',
-                  },
-                },
-                dependsOn: {
-                  type: 'array',
-                  items: {
-                    type: 'string',
-                  },
-                },
-                restart: {
-                  type: 'string',
-                  enum: ['no', 'always', 'on-failure', 'unless-stopped'],
-                },
-                user: {
-                  type: 'string',
-                },
-                workdir: {
-                  type: 'string',
-                },
-                entrypoint: {
-                  type: 'string',
-                },
-                privileged: {
-                  type: 'boolean',
-                },
-                expose: {
-                  type: 'array',
-                  items: {
-                    type: 'string',
-                  },
-                },
-                healthcheck: {
-                  type: 'object',
-                  properties: {
-                    test: {
-                      oneOf: [
-                        { type: 'string' },
-                        {
-                          type: 'array',
-                          items: { type: 'string' },
-                        },
-                      ],
-                    },
-                    interval: {
-                      type: 'string',
-                    },
-                    timeout: {
-                      type: 'string',
-                    },
-                    retries: {
-                      type: 'number',
-                    },
-                    start_period: {
-                      type: 'string',
-                    },
-                  },
-                  required: ['test'],
-                  additionalProperties: false,
-                },
-              },
-              required: ['image'],
-              additionalProperties: false,
-            },
-          },
-          additionalProperties: false,
-        },
-        networks: {
-          type: 'object',
-          patternProperties: {
-            '^[a-zA-Z0-9_-]+$': {
-              type: 'object',
-            },
-          },
-          additionalProperties: false,
-        },
-        volumes: {
-          type: 'object',
-          patternProperties: {
-            '^[a-zA-Z0-9_-]+$': {
-              type: 'object',
-            },
-          },
-          additionalProperties: false,
-        },
-        ttl: {
-          type: 'number',
-        },
-        log: {
-          $ref: '#/$defs/Runium_TaskLog',
-        },
-      },
-      required: ['services'],
-      additionalProperties: false,
-    },
-  };
-}

package/src/validation/docker-task-project-schema.ts

@@ -1,68 +0,0 @@
-import { ProjectSchemaExtensionTask } from '@runium/types-plugin';
-
-export function getDockerTaskProjectSchema(): ProjectSchemaExtensionTask {
-  return {
-    type: 'docker',
-    options: {
-      type: 'object',
-      properties: {
-        image: {
-          type: 'string',
-        },
-        containerName: {
-          type: 'string',
-        },
-        command: {
-          type: 'string',
-        },
-        arguments: {
-          type: 'array',
-          items: {
-            type: 'string',
-          },
-        },
-        ports: {
-          type: 'array',
-          items: {
-            type: 'string',
-          },
-        },
-        volumes: {
-          type: 'array',
-          items: {
-            type: 'string',
-          },
-        },
-        env: {
-          $ref: '#/$defs/Runium_Env',
-        },
-        network: {
-          type: 'string',
-        },
-        autoRemove: {
-          type: 'boolean',
-        },
-        user: {
-          type: 'string',
-        },
-        workdir: {
-          type: 'string',
-        },
-        entrypoint: {
-          type: 'string',
-        },
-        privileged: {
-          type: 'boolean',
-        },
-        ttl: {
-          type: 'number',
-        },
-        log: {
-          $ref: '#/$defs/Runium_TaskLog',
-        },
-      },
-      required: ['image'],
-      additionalProperties: false,
-    },
-  };
-}

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "target": "esnext",
-    "outDir": "./lib",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "module": "esnext",
-    "moduleResolution": "node",
-    "forceConsistentCasingInFileNames": true,
-    "declaration": false,
-    "sourceMap": false,
-    "strictNullChecks": true,
-    "removeComments": true,
-    "allowSyntheticDefaultImports": true,
-    "types": ["node", "@runium/types-plugin"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}