Tasks Reference

Oidis Builder has 120+ built-in tasks, grouped into categories. Tasks are invoked by name using oidis task <name> or the task:option syntax.

For the task system architecture, see Overview.

Composition Tasks

Core orchestration tasks that drive build workflows.

Task name	Class	Description
`install`	`Install`	Prepare project dependencies and environment
`compile`	`Compile`	Orchestrate multi-language compilation
`copy`	`Copy`	Copy files to target
`copy-local-scripts`	`CopyLocalScripts`	Copy build scripts to target
`copy-scripts`	`CopyScripts`	Copy resource scripts
`copy-staticfiles`	`CopyStaticFiles`	Copy static resource files
`code-sign`	`CodeSign`	Sign binaries (Windows Authenticode, macOS notarization)
`dependencies-sort`	`DependenciesSort`	Topologically sort dependency list
`dependencies-download`	`DependenciesDownload`	Download/clone project dependencies
`install-local-script`	`DependenciesInstall`	Run dependency install scripts
`upx`	`Upx`	Compress executables with UPX
`compress`	`TargetCompress`	Create ZIP archive of build target

`compile` — Compilation Orchestrator

Options: dev, eap, prod

Detects which languages are present and runs the appropriate compilation chain. Skips languages not found in the project. See Build Process for the detailed pipeline.

oidis task compile:dev
oidis task compile:prod

`install` — Dependency Setup

Options: dev, eap (default: prod)

oidis install            # full dependency install + cleanup
oidis task install:dev   # dev-mode install (faster, partial cleanup)

Build Processor Tasks

Internal tasks that orchestrate the full build-machine pipeline.

Task name	Class	Description
`build`	`BuildExecutor`	Full build orchestrator — resolves platform chain
`build-machine`	`BuildStateMachine`	Per-product build state machine
`build-settings`	`BuildSettings`	Configure build type (dev/prod/eap)
`product-settings`	`ProductSettings`	Apply per-release/platform overrides
`module-executor`	`ModuleExecutor`	Execute a module task

`build` / `build-machine` — Build Pipeline

Options: dev, eap, prod, rebuild, rebuild-dev, rebuild-eap

The main build entry point. Resolves the full task chain per release and platform, then executes it.

oidis build prod
oidis build dev --with-test
oidis rebuild-eap

Cleanup Tasks

Task name	Class	Description
`project-cleanup`	`ProjectCleanup`	Remove generated files
`git-cleanup`	`GitCleanup`	Revert git-tracked files to clean state
`config-cleanup`	`ConfigCleanup`	Remove generated config artifacts
`typescript-cleanup`	`TypeScriptCleanup`	Remove compiled TypeScript output
`sass-cleanup`	`SassCleanup`	Remove compiled SASS output
`scr-cleanup`	`SCRCleanup`	Validate and deduplicate SW-Content-Register entries
`structure-cleanup`	`StructureCleanup`	Remove project structure artifacts
`dev-blocks-cleanup`	`DevBlocksCleanup`	Remove dev-only code from compiled output
`copyrights-cleanup`	`CopyrightsCleanup`	Enforce copyright headers (pre-commit hook)

`project-cleanup` — Remove Generated Files

Options: all, build, cache, source, test, init, prod

oidis clean               # equivalent to project-cleanup:all
oidis task project-cleanup:build    # delete build/ only
oidis task project-cleanup:cache    # delete build_cache/ only
oidis task project-cleanup:source   # delete compiled JS in source/
oidis task project-cleanup:test     # delete test artifacts

`dev-blocks-cleanup` — Strip Dev Code

Removes code between // @dev-block-start and // @dev-block-end markers from compiled output. Run automatically during prod and eap builds.

See Dev Markers for how to use dev blocks in your code.

`copyrights-cleanup` — Copyright Header Enforcement

Validates and fixes copyright year ranges in all source files. Used as a pre-commit git hook. Copyright years must match the actual create/modify dates of each file.

oidis task copyrights-cleanup

TypeScript Tasks

Task name	Class	Description
`typescript`	`TypeScriptCompile`	Compile TypeScript source
`typescript-interfaces`	—	Generate interface registration code
`typescript-mappings`	`TypeScriptMappings`	Generate namespace mapping files
`typescript-reference`	—	Generate TypeScript reference files
`typescript-lint`	—	Lint TypeScript with ESLint
`cache-manager`	`CacheManager`	TypeScript incremental build cache management

`typescript` — TypeScript Compilation

Options: source, unit, selenium

oidis task typescript:source     # compile main source
oidis task typescript:unit       # compile unit tests
oidis task typescript:selenium   # compile Selenium tests

Supports both UMD (outModule bundling) and ES module mode (determined by toolchainSettings.version: "module").

`cache-manager` — Incremental Build Cache

Options: generate-ts, generate-prod-ts, generate-sass, prepare-ts, finalize-ts, finalize-prod-ts, finalize-sass, finalize-<toolchain>

Manages SHA1-based file cache for incremental compilation. Automatically invalidated on configuration change.

SASS Tasks

Task name	Class	Description
`sass-compile`	—	Compile SASS/SCSS to CSS
`sass-reference`	`SassReference`	Generate SASS reference/import map
`sass-compress`	`SassCompress`	Minify compiled CSS
`sass-lint`	—	Lint SASS with Stylelint
`cssmin`	—	CSS minification (prod/eap builds)

`sass-compile` — SASS Compilation

Options: source, dependencies

oidis task sass-compile:source         # compile project SASS
oidis task sass-compile:dependencies   # compile dependencies' SASS

Testing Tasks

Task name	Class	Description
`test`	`TestAll`	Testing orchestrator
`run-unit-test`	`RunUnitTest`	Run TypeScript unit tests
`run-coverage-test`	`RunCoverageTest`	Run code coverage analysis
`build-check`	`BuildCheck`	Validate build output
`test-lint-staged-only`	`TestLintStaggedOnly`	Lint only staged git files
`selenium-server-start`	`SeleniumServerStart`	Start Selenium WebDriver server
`selenium-server-stop`	`SeleniumServerStop`	Stop Selenium WebDriver server
`virtualbox-server`	`VirtualBoxServer`	Manage VirtualBox VM for testing

`test` — Testing Orchestrator

Options: all, lint, code, tslint, sasslint, jslint, xcpplint, javalint, pythonlint, typescriptunit, xcppunit, pythonunit, xcppcoverage, coverage, selenium

oidis test all              # run everything
oidis test lint             # all linters
oidis test unit             # TypeScript unit tests
oidis test coverage         # coverage analysis
oidis test selenium         # Selenium integration tests

# CLI shorthand
oidis task test:tslint      # TypeScript lint only
oidis task test:sasslint    # SASS lint only
oidis task test:xcppunit    # C++ unit tests only

`run-unit-test` — Unit Test Runner

oidis test unit                           # run all unit tests
oidis test unit path/to/MyTest.spec.ts    # run single test file

Use --ignore-tests=file1,file2 to exclude specific test files.

JavaScript Tasks

Task name	Class	Description
`jslint`	`JSLint`	Lint JavaScript with ESLint
`uglify`	`JSCompress`	Minify JavaScript with UglifyJS
`gyp-compile`	`GypCompile`	Build native Node.js modules with node-gyp

`uglify` — JavaScript Minification

Options: prod, loader

oidis task uglify:prod     # minify production output
oidis task uglify:loader   # minify loader script

Deploy Tasks

Task name	Class	Description
`deploy`	`Deploy`	Deploy packaged build to a server
`config-deploy`	`ConfigDeploy`	Deploy configuration files
`target-deploy`	`TargetDeploy`	Deploy compiled target
`update-deploy`	`UpdateDeploy`	Manage update deployments
`release-platform`	`ReleasePlatform`	Register a release platform after build

`deploy` — Deployment

Options: dev, eap, prod

CLI flags: --action, --id, --upload-to, --filter

See Deploy for detailed deployment documentation.

oidis deploy:dev
oidis deploy:prod --action=list

Run Tasks

Task name	Class	Description
`run`	`Run`	Build and run the development release
`forward-task`	`TaskForward`	Forward task to Hub/Service
`remote-attach`	`RemoteAttach`	Attach to remote debugger

`run` — Development Run

oidis run                          # run default config
oidis run --run-config=demo        # run named config
oidis run:demo                     # shortcut

Supports local execution, Hub/Service forwarding, and cloud sync.

Documentation Tasks

Task name	Class	Description
`docs`	`Docs`	Documentation orchestrator
`typedoc-generate`	`TypedocGenerate`	Generate TypeDoc API docs (TypeScript)
`doxygen-generate`	`DoxygenGenerate`	Generate Doxygen docs (C++)
`markdown-generate`	`MarkdownGenerate`	Generate Markdown docs
`scr-generate`	`SCRGenerate`	Generate SCR documentation

oidis docs       # generate all documentation

Output: build/target/docs/

`scr-generate` — Software Content Register

scr-generate generates build/target/SW-Content-Register.txt — a plain-text inventory of all software components included in a release, together with their versions, authors, licenses, formats, and file-system locations. The file serves as a license compliance record for audits and deliveries.

File format

Release Name: {package-name} v{version}

{component-name} v{version}
Description: {description}
Author: {author}
License: {license-identifier}. See {license-file}
Format: {format}
Location: {path1},
          {path2},
          {path3}

{next-component}...

Rules:

Header line Release Name: identifies the owning project and its version.
Each component block is separated by a blank line.
A component marked [OPTIONAL] gets that tag on its own line before the name line.
Location: continuation lines are indented with 10 spaces; each line except the last ends with a comma.
Line endings follow the target OS (\r\n on Windows, \n on POSIX).

Common Format values: source code, executable binary, static library, native module, web font.

Configuration — `licensesRegister.jsonp`

Component metadata is configured in licensesRegister.jsonp, referenced from package.conf.jsonp:

// bin/project/configs/licensesRegister.jsonp
{
    "my-package": {
        format: "source code",
        location: [
            "resource/esmodules-[build-time]/Io/My/Package",
            "resource/css/[package-name]-[version].min.css"
        ]
    },
    "some-npm-dep": {
        optional: true,
        location: ["[application-name][.exe]/resource/libs/SomeDep"]
    }
}

Location paths may use placeholder tokens: [application-name], [package-name], [version], [build-time], [target/], [.exe], [.dll], [.lib], [.cmd].

Per-component defaults when the dependency is resolved via dependencies/**/package.conf.json:

description — from the dependency's package.conf.json
author — "Oidis" (for Oidis packages) or "N/A"
license — "BSD-3-Clause. See LICENSE.txt"
format — "source code"

`scr-cleanup`

After scr-generate, scr-cleanup runs as part of the docs pipeline. It parses the generated file, removes duplicate entries, merges records from nested dependency SCR files, and re-serialises the result in canonical format.

Manual SCR for non-Builder projects

Projects that do not use Oidis Builder (e.g. standalone tooling packages) should create and commit SW-Content-Register.txt manually in the project root. Place it in the root rather than build/target/ so it is always present in the repository without requiring a build step.

Steps:

Copy the format above.
Fill in the main project block (name, version, description, BSD-3-Clause. See LICENSE.txt).
Add one block per runtime dependency (npm packages, bundled runtimes, native modules).
Mark truly optional components (e.g. OS-specific native modules) with [OPTIONAL].
Commit the file — it is static and must be updated manually when dependencies change.

Java Tasks

Task name	Class	Description
`maven-build`	`MavenBuild`	Build Java project with Maven
`maven-env`	`MavenEnv`	Set up Maven environment
`java-lint`	`JavaLint`	Lint Java with Checkstyle
`java-packaging`	`JavaPackaging`	Package compiled Java (JAR)
`init-target`	`InitTarget`	Initialize Java build target
`config-compile`	`ConfigCompile`	Compile Java configurations
`manifest-classpath`	`ManifestClasspath`	Manage JAR manifest classpath
`plugin-configs`	`PluginConfigs`	Configure IDE plugins
`plugin-clean-compile`	`PluginCleanCompile`	Clean-compile IDE plugins

Python Tasks

Task name	Class	Description
`python-compile`	`PythonCompile`	Compile Python to bytecode
`python-lint`	`PythonLint`	Lint Python with Pylint
`python-test`	`PythonTest`	Run Python unit tests
`python-install`	`PythonInstall`	Set up Python virtual environment
`python-packaging`	`PythonPackaging`	Package Python (wheel/egg)

C++ / XCpp Tasks

Task name	Class	Description
`xcpp-compile`	`XCppCompile`	Compile C++ source
`xcpp-test`	`XCppTest`	Run C++ unit tests
`xcpp-cache-register`	`XCppCacheRegister`	Manage C++ build cache
`xcpp-lint`	—	Lint C++ with CppCheck
`xcpp-interfaces`	—	Generate XCpp interface files
`xcpp-reference`	—	Generate XCpp reference files

`xcpp-compile` — C++ Compilation

Options: source, unit, dependencies

oidis task xcpp-compile:source        # compile C++ source
oidis task xcpp-compile:unit          # compile C++ unit tests
oidis task xcpp-compile:dependencies  # compile dependency C++ code

`xcpp-test` — C++ Testing

Options: unit, coverage

Server Tasks

Task name	Class	Description
`builder-service`	`BuilderService`	Manage Builder service (start/stop)
`builder-agent`	`BuilderAgent`	Connect Builder to Oidis Hub as agent
`connector-service`	`ConnectorService`	Manage connector service
`dashboard`	`Dashboard`	Start Builder dashboard server
`mock-server`	`MockServer`	Start mock HTTP server for testing
`selenium-server-start`	`SeleniumServerStart`	Start Selenium WebDriver
`selenium-server-stop`	`SeleniumServerStop`	Stop Selenium WebDriver

`builder-service` — Builder Service

Options: start, stop

oidis service              # start service (oidis service = oidis builder-service:start)
oidis service stop         # stop service

The service runs in the background and accepts forwarded tasks from oidis --service.

`mock-server` — Mock HTTP Server

Starts a configurable mock HTTP server for development and testing. Configured via target.mockServer in package.conf.jsonp:

"target": {
    "mockServer": {
        "port": 8080,
        "config": "resource/configs/mock-server.json"
    }
}

Utility Tasks

Task name	Class	Description
`string-replace`	`VariableReplace`	Substitute variables in files
`version-update`	`VersionUpdate`	Update version in config files
`ntfy-notify`	`NtfyNotify`	Send push notification via ntfy
`selfupdate`	`Selfupdate`	Self-update the Builder installation
`cloud-sync-manager`	`CloudSyncManager`	Sync with cloud storage
`install-idea-tools`	`InstallIdeaTools`	Install IntelliJ IDEA tools
`key-ring`	`KeyRing`	Manage cryptographic keys
`crypto-environment`	`CryptoEnvironment`	Set up encryption/decryption environment
`wui-app-kill`	`WuiAppKill`	Terminate running WUI application process
`snippet`	`Snippet`	Empty stub for custom development work

`string-replace` — Variable Substitution

Options: var-replace, xcpp, variables-plugin, dependencies

Substitutes @var placeholder expressions in source files with values from build configuration.

`version-update` — Version Management

oidis task version-update --new-version=2026.1.0

Updates version field in package.conf.jsonp and any other configured version files.

`ntfy-notify` — Push Notification via ntfy

Sends a push notification to a mobile device using the ntfy service. Useful for alerting a developer when a long build finishes, requesting human approval before a destructive action, or notifying from an AI agent (e.g. Claude Code) that manual input is needed.

Configuration: ntfyConfig in package.conf.jsonp (or private.conf.jsonp for personal topics). Defaults are provided by the builder's commons.jsonp. See ntfyConfig in the Configuration Reference.

# Send a notification with a custom message
oidis ntfy-notify --description="Production deploy ready — please approve."

# Inline option form (short message as task option)
oidis ntfy-notify:build-done

The task never fails the build — if the HTTP request fails (network issue, wrong topic, etc.), a warning is logged and execution continues normally.

Claude Code Integration

This task is designed to work with Claude Code running in an agentic / autonomous mode. When Claude needs human approval before continuing (e.g. deploying to production, running a destructive migration, or confirming a non-trivial change), it can call ntfy-notify via the Bash tool to push a notification to your phone so you can review and respond without watching the terminal:

oidis ntfy-notify --description="I need you to approve the production deploy before I continue."

Install the ntfy app (Android / iOS), subscribe to your topic, and you will receive real-time alerts from any build or AI agent session running on your machine.

`selfupdate` — Builder Self-Update

oidis update               # shorthand
oidis task selfupdate      # direct task
oidis task selfupdate:check  # check for update, apply if available

Runtime Tasks

Task name	Class	Description
`selfinstall`	`Selfextractor`	Create self-extracting installer
`wui-modules-release`	`WuiModulesRelease`	Package WUI runtime modules into release
`wui-modules-download`	`WuiModulesDownload`	Download WUI runtime modules
`phonegap-build`	`PhonegapBuild`	Build mobile app with PhoneGap

`wui-modules-download`

Downloads the WUI runtime modules (Chromium Embedded, Connector, Launcher) from Oidis Hub into <appdata>/wui_modules/. Required for app type builds with chromium-re toolchain.

oidis task wui-modules-download       # download if not present
oidis task wui-modules-download:force # force re-download

Client Tasks

Task name	Class	Description
`forward-task`	`TaskForward`	Forward task to Hub/Service client
`client-report`	`ClientReport`	Report client build status
`builder-client`	`BuilderClient`	Manage client connection to service

General Tasks

Task name	Class	Description
`solution-loader`	`SolutionLoader`	Load target project configuration (always first task)
`system-info`	`SystemInfo`	Display system and builder information

`solution-loader` — Target Config Loader

Always the first task executed. Loads package.conf.jsonp from the target project, resolves imports, applies the active solution, and merges private.conf.jsonp. If dependencies/ is empty, triggers dependency download automatically.

This task runs automatically — you do not need to invoke it manually.

TypeScript AST Inspection Tasks (Internal)

Used internally by TypeScriptCompile to inspect the compiled program (the ForceCompile.ts generated block is built from a plain text match, not from these classes):

Task name	Class	Description
—	`TsEntity`	Analyze TypeScript entities (classes, interfaces)
—	`TsImport`	Analyze TypeScript import statements
—	`TsNode`	Base AST node analysis
—	`TsParam`	Analyze method parameters
—	`TsMethod`	Analyze method declarations

See also: Build Process | CLI Reference | Testing

Composition Tasks​

compile — Compilation Orchestrator​

install — Dependency Setup​

Build Processor Tasks​

build / build-machine — Build Pipeline​

Cleanup Tasks​

project-cleanup — Remove Generated Files​

dev-blocks-cleanup — Strip Dev Code​

copyrights-cleanup — Copyright Header Enforcement​

TypeScript Tasks​

typescript — TypeScript Compilation​

cache-manager — Incremental Build Cache​

SASS Tasks​

sass-compile — SASS Compilation​

Testing Tasks​

test — Testing Orchestrator​

run-unit-test — Unit Test Runner​

JavaScript Tasks​

uglify — JavaScript Minification​

Deploy Tasks​

deploy — Deployment​

Run Tasks​

run — Development Run​

Documentation Tasks​

scr-generate — Software Content Register​

File format​

Configuration — licensesRegister.jsonp​

scr-cleanup​

Manual SCR for non-Builder projects​

Java Tasks​

Python Tasks​

C++ / XCpp Tasks​

xcpp-compile — C++ Compilation​

xcpp-test — C++ Testing​

Server Tasks​

builder-service — Builder Service​

mock-server — Mock HTTP Server​

Utility Tasks​

string-replace — Variable Substitution​

version-update — Version Management​

ntfy-notify — Push Notification via ntfy​

selfupdate — Builder Self-Update​

Runtime Tasks​

wui-modules-download​

Client Tasks​

General Tasks​

solution-loader — Target Config Loader​

TypeScript AST Inspection Tasks (Internal)​