Registry / devops / strong-docker-build

strong-docker-build

JSON →
library1.1.1jsnpmunverified

strong-docker-build is a utility within the StrongLoop ecosystem, specifically designed to build Docker images for applications managed by strong-supervisor. Currently at version 1.1.1, the package was last published over 10 years ago in May 2016, indicating it is no longer actively maintained and can be considered abandoned. Its release cadence has ceased. The tool was created during the period when StrongLoop was a prominent platform for Node.js APIs and microservices, before its acquisition by IBM in 2015 and the subsequent open-sourcing of key frameworks like LoopBack under the Cloud Native Computing Foundation (CNCF). This package's primary differentiator was its tight integration with `strong-supervisor` for deploying and managing Node.js applications within a Dockerized environment, a workflow that has largely been superseded by more modern Docker and cloud-native deployment patterns. Developers should be aware of its unmaintained status and consider contemporary alternatives for Docker image building and Node.js application deployment.

npm install strong-docker-build
INSTALL
IMPORT
SIG · STRONG-DOCKER-BUIL
S
strong-docker-build
devopsjavascriptv1.1.1
Install
Import
Disk
Pass rate
0/ 6
Env Coverage0 / 6
glibc
1822
musl
1822
Install & Compatibility
Where this runs
tested against v? · npm install
Install × environment matrix
Each cell = how many times install + import succeeded across repeated harness runs. Partial = flaky.
glibc = Debian/Ubuntu slim · musl = Alpine Linux
musl
node 18226 runs
build_error
glibc
node 18226 runs
build_error
Code
Verified usage

Verified import paths — ran on the pinned version, not inferred.

CLI Usage
strong-docker-build <path-to-app>
import { build } from 'strong-docker-build'
This package is primarily a command-line interface (CLI) tool. Direct programmatic imports for general use are not commonly documented or intended. It expects a StrongLoop/strong-supervisor application context.
Main Module (CommonJS)
const buildTool = require('strong-docker-build'); // buildTool.build(...) (hypothetical programmatic API)
import buildTool from 'strong-docker-build';
If a programmatic API exists, it would be CommonJS. Attempting to use ES Modules (import) directly will result in errors in most Node.js environments without transpilation due to the package's age. The actual programmatic interface is not well-documented.
Type Definitions
// No type definitions available
import type { BuildOptions } from 'strong-docker-build';
This package predates widespread TypeScript adoption and does not ship with its own type definitions. No community types (@types/strong-docker-build) are available.

Demonstrates the conceptual workflow for building a Docker image of a strong-supervisor managed Node.js application using strong-docker-build, including necessary project structure and a Dockerfile. This tool is primarily CLI-driven.

/* This quickstart demonstrates how to conceptually use strong-docker-build to create a Docker image for a simple Node.js application managed by strong-supervisor. Note: strong-docker-build is abandoned, consider modern alternatives like Docker BuildKit. */ // 1. Create a simple Node.js application (e.g., 'my-app/index.js') // file: my-app/index.js const http = require('http'); const port = process.env.PORT || 3000; const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader('Content-Type', 'text/plain'); res.end('Hello from strong-supervisor-managed app!\n'); }); server.listen(port, () => { console.log(`Server running at http://localhost:${port}/`); }); // 2. Add a package.json for strong-supervisor (e.g., 'my-app/package.json') // file: my-app/package.json /* { "name": "my-app", "version": "1.0.0", "description": "A simple app for strong-supervisor", "main": "index.js", "scripts": { "start": "sl-run ." }, "dependencies": { "strong-supervisor": "^5.0.0" // Or appropriate version } } */ // 3. Create a Dockerfile (e.g., 'my-app/Dockerfile') // This Dockerfile sets up the application to be run by strong-supervisor. /* FROM node:lts-slim WORKDIR /app COPY package*.json ./ RUN npm install --production COPY . . EXPOSE 3000 CMD ["npm", "start"] */ // 4. Navigate to the application directory and (hypothetically) run strong-docker-build // In a real scenario, you would execute this from your terminal: // cd my-app // strong-docker-build . // (This command assumes 'strong-docker-build' is installed globally or accessible in PATH) console.log('Setup instructions for strong-docker-build are above.'); console.log('In your terminal, navigate to the `my-app` directory and run: strong-docker-build .'); console.log('This would build a Docker image named after your app based on the Dockerfile.');
Debug
Known issues
breakingThe strong-docker-build package is considered abandoned, having been last published in May 2016. It is part of the deprecated StrongLoop ecosystem. Using unmaintained software poses significant security risks and compatibility challenges with modern Node.js and Docker environments.
fix
Migrate to modern Docker build practices, such as native `docker build` commands, multi-stage builds, and CI/CD pipelines with tools like GitHub Actions or GitLab CI. For Node.js applications, ensure you are using up-to-date Node.js versions and containerization best practices.
affects: >=1.0.0
gotchaThis tool is tightly coupled with `strong-supervisor` and the broader StrongLoop application structure. It assumes your application is configured to be managed by `strong-supervisor` via its `package.json` `start` script (e.g., `sl-run .`).
fix
If not using `strong-supervisor`, this tool is likely inappropriate. If migrating, remove `strong-supervisor` dependencies and update your Dockerfile to use a standard Node.js `CMD` or `ENTRYPOINT` to start your application.
affects: >=1.0.0
gotchaAs an older Node.js package, strong-docker-build predates ES Module (ESM) standardization and is strictly CommonJS (CJS). Attempting to `import` it directly in an ESM context will lead to runtime errors.
fix
If programmatic interaction is necessary (which is uncommon for this CLI-focused tool), use `require('strong-docker-build')` in CJS files. For modern projects, it's advisable to avoid programmatic integration and use its CLI or migrate away.
affects: >=1.0.0
gotchaThe package likely does not leverage modern Docker BuildKit features for optimized builds, such as improved caching or secure secret management during builds.
fix
When migrating to `docker build`, explicitly enable BuildKit (`DOCKER_BUILDKIT=1 docker build ...`) and utilize its `--secret` and `--cache-from` features for more secure and efficient builds.
affects: >=1.0.0
gotchaThere is a lack of comprehensive, up-to-date documentation and community support for strong-docker-build, making troubleshooting difficult.
fix
Rely on contemporary Docker and Node.js documentation for building and deploying applications. If stuck, consider asking in general Docker or Node.js communities rather than specific StrongLoop forums.
affects: >=1.0.0
Errors
Common errors & fixes
Error: Cannot find module 'strong-supervisor'
The application inside the Docker image is configured to use strong-supervisor, but it was not correctly installed or packaged into the image.
fix
Ensure `strong-supervisor` is listed in your application's `package.json` dependencies and `npm install` is run within your Dockerfile prior to copying the application code. Verify the `CMD` or `ENTRYPOINT` in the Dockerfile correctly invokes `strong-supervisor` (e.g., `npm start` if `start` script is `sl-run .`).
Error: Docker daemon not running. Is Docker installed and running?
The Docker daemon is not active on the machine where strong-docker-build is being executed, preventing it from interacting with the Docker engine.
fix
Start your Docker Desktop application or ensure the Docker daemon process is running on your server. On Linux, you might use `sudo systemctl start docker` or `sudo service docker start`.
Image build failed: The command '/bin/sh -c npm install --production' returned a non-zero code: X
An error occurred during one of the `RUN` commands in the Dockerfile, most commonly during dependency installation (`npm install`) or a build step.
fix
Examine the output logs immediately preceding the error for specific details. This often indicates issues with network access for npm, incompatible Node.js versions, missing build tools in the base image, or errors in your `package.json`.
Upgrade
Version history
1.1.1latest on npm
Audit
Dependencies

No dependency data recorded yet.

Agent activity
5 hits · last 30 days
node
4
Bingbot
1
Resources