Use ShipitJS as the SSH-based orchestration layer for your VPS deployment: install shipit-cli and shipit-deploy, define the server, repository, SSH key and release policy in shipitfile.js, then run npx shipit production deploy. Shipit fetches the selected Git revision, creates a numbered release, switches the current symlink and removes releases beyond your retention limit.
Antihost offers Linux VPS plans with full root access, unlimited traffic on a 1 Gbps port and a 14-day free trial.
Shipit does not run Node.js or supervise your application process. Add explicit tasks for locked dependency installation, builds, migrations, process reloads and health checks, using systemd or another process manager on the VPS. The result is repeatable releases with a practical rollback path instead of an ad-hoc SSH script.
As an Amazon Associate I earn from qualifying purchases.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →What ShipitJS does—and what it does not
ShipitJS describes itself as “an automation engine and a deployment tool.” It is a JavaScript task runner that connects to servers over SSH and coordinates deployment steps. It is not the Node.js runtime, a web server, a database migration framework or a process supervisor.
This guide is about the shipitjs/shipit project and its shipit-deploy plugin. A different project named ShipIt documents provisioning a VPS-hosted application; its commands and operating-system assumptions do not apply here.
#1 Best Overall
- [Ultra-Lightweight Ear Buds Designed for Small Ears] Each earbud weighs only 3.7g and features a compact, ergonomic in-ear design made especially for small ears. Secure, low-profile, and comfortable for workouts, all-day wear or overnight sleeping.The ultra-slim profile sits flush in your ear with no hard edges poking or rubbing, so you can even sleep on your side without discomfort.
- [Immersive Stereo Sound with TOZO OrigX Technology] TOZO OrigX tuning delivers clear vocals, balanced mids, and natural stereo sound for music, podcasts, and videos.
- [Long Battery Life for Daily Use] Get up to 7 hours of playtime on a single charge, with up to 32 hours total using the charging case—ideal for workdays, commuting, and extended listening sessions.
- [Bluetooth 5.3 & Stable Connection] Bluetooth 5.3 provides fast pairing, stable wireless performance, and reduced dropouts as you move around home or office.
- [Deep Bass with Clear Vocals] High-performance drivers produce punchy bass while keeping vocals clean and detailed for everyday listening.
- Shipit handles: SSH execution, Git-based release preparation, release directories, the
currentsymlink, retention cleanup, task orchestration and lifecycle events. - Your application tasks handle:
npm ci, compilation, database migrations, cache warming, process reloads and HTTP checks. - Your VPS handles: the Node.js runtime, operating-system services, firewalling, logs, TLS termination and persistent data.
Keeping those boundaries explicit prevents a common production mistake: assuming that a successful Shipit command means the new Node process is running or that the application is healthy.
How a Shipit deployment works
The deployment plugin uses a release-directory model. A typical run performs these operations in order:
- Shipit creates a local workspace for the deployment.
- It fetches the selected Git revision and checks it out.
- It creates a new release directory below your remote deployment root.
- It copies the checked-out project into that release.
- It changes the
currentsymlink to point at the new release. - It removes releases older than the configured retention count.
- It emits lifecycle events that your application-specific tasks can use.
Because the symlink changes as one publication step, the process manager can be reloaded against a complete release rather than a directory that is being copied in place. The previous release remains available until retention cleanup removes it, which is what makes a symlink-based rollback practical.
What is actually rolled back
npx shipit production rollback republishes a prior retained release through the same symlink mechanism. It does not automatically reverse a database migration, restore uploaded files or undo an external API change. Treat schema changes and other stateful operations as separate, reversible plans.
Prerequisites on your workstation, CI runner and VPS
Shipit runs from a workstation or CI runner. The VPS needs the tools required by the release and by your application.
Workstation or CI runner
- Node.js and npm, with a version compatible with the Shipit packages and your project.
- Git and network access to the repository.
- An SSH private key readable by the account running Shipit.
- Known-host verification for the VPS, preferably preloaded rather than accepted interactively during an automated job.
VPS
- A dedicated non-root deployment account, such as
deploy. - SSH access for that account and the matching public key in
authorized_keys. - Git if the remote release workflow needs to access the repository directly; with the documented workflow, Shipit prepares the revision and transfers it, so confirm the exact plugin behavior for your installed version.
- The Node.js runtime and npm version required by the application.
- A process manager, normally a systemd service or another supervisor, configured before the first production release.
- Outbound access to your package registry, Git host and any services needed during builds or migrations.
- Enough disk space for the active release plus the number of retained releases.
Create the remote root before deploying, for example /var/apps/my-node-app, and make the deploy account its owner. Do not give the account unrestricted root access merely so a restart command succeeds; if elevated service control is necessary, allow only the specific command through a narrowly scoped sudoers rule.
Install ShipitJS in the project
The documented installation uses development dependencies:
npm install --save-dev shipit-cli
npm install --save-dev shipit-deployCommit the resulting package manifest and lockfile. Running the CLI through npx then uses the version recorded by the project rather than an unrelated global installation.
Rank #2
- 【IP68 Waterproof Multifunctinal Smart Watch】Torjalph fitness activity tracker smart watch is IP68 waterproof technology ,you can wear it when swimming,handwashing,it's rain-proof which means that you perform multiple exercise modes outside without worrying about sweat or rain corroding your fitness smart watch,and this watch equipped with a 230 mAh large capacity battery magnetic charging ,and this sports activity tracker watch can be used 5-7 days If fully charged.
- 【Larger 1.83'' Full Screen Watch & Multi-dial Selection】1.83 inch full HD color touch screen smart watch for men / women provides excellent 240*284 resolution image quality ,This Bluetooth smart watch offers a better touch experience and remarkable immersion and ,more than 200 watch faces for you to choose from App"Da Fit ", you can change the dial style according to your mood to wear keeping the world on your wrist
- 【Accurate Activity Tracker Smart Watch 】sports watch activity tracker uses sweat and dust resistant breathable silicone strap, our Fitness Tracker Smart Watch for Android iOS Phones supports 12 sports modes,walking,running,bicycle,swimming,badminton,basketball,football,rope skipping. This bluetooth calls smart watch for men women is lightweight and stylish, bringing more convenient and relaxing sports experience while also providing more protection.
- 【Your 24 Hour Personal Daily Health Monitor】Fitness watch for women men full touch screen IP67 waterproof bluetooth smartwatch for Android iOS Phones with heart rate blood pressure monitor multifunction Andriod smart watch with steps counter sleep monitor sports fitness watch, monitoring blood oxygen saturation allows you to understand your physical condition in real time to track fitness progress ,to know your health status in time.
- 【More Functions Bluetooth Call Smart Watch】This fitness activity smart watch full screen for iPhone and Android phones includes a bunch of new features including:The bluetooth smart watch can hang up the phone, receive and display WhatsAPP /Text /Facebook /Twitter /Messenger reminder.Support sedentary reminder, alarm clock, stopwatch, timer,weather information,music control, remote camera control compatible with Android 5.0 and above or iOS 9.0 and above smartphones.
Create a production shipitfile
At the project root, create shipitfile.js with a default configuration and a production server target:
module.exports = shipit => {
require('shipit-deploy')(shipit)
shipit.initConfig({
default: {
deployTo: '/var/apps/my-node-app',
repositoryUrl: 'https://github.com/example/my-node-app.git',
key: '/home/deploy/.ssh/id_ed25519',
keepReleases: 5,
shallowClone: true
},
production: {
servers: '[email protected]'
}
})
}The example follows the project’s documented pattern. Replace the repository, host, account and key path with values for your environment.
Recommended Free Tools
Configuration fields
| Field | Purpose | Production decision |
|---|---|---|
deployTo |
Remote deployment root. | Use a dedicated path such as /var/apps/my-node-app; make it writable by the deploy account. |
repositoryUrl |
Git source for the release. | Use HTTPS or git+ssh. Pin the branch or revision intentionally rather than relying on an accidental local working tree. |
servers |
SSH destination. | The shorthand is user@host. A structured server object can specify user, host, port and additional SSH options when the shorthand is insufficient. |
key |
Private key used by the SSH connection. | Keep it outside the repository and restrict its filesystem permissions. In CI, inject it as a secret and remove it after the job. |
keepReleases |
Number of releases retained after cleanup. | Five is the documented example, not a universal recommendation. Choose a value that leaves rollback options without exhausting disk space. |
shallowClone |
Whether the deployment uses a shallow Git checkout. | The documented configuration defaults this to true. Set it according to whether your build needs tags or complete history. |
Do not place database passwords, session secrets or API keys in this file. Keep runtime configuration in the VPS service environment or a protected secret store, and grant the deploy process only the access it needs.
Prepare the VPS for an atomic release
1. Create the deploy account and SSH trust
Use a dedicated account and a key restricted to deployment. Verify the server fingerprint out of band and add the expected host key to the runner’s known_hosts file. A non-interactive deployment should fail on an unknown host rather than silently trust a changed key.
2. Install the runtime and service definition
Install the Node.js version declared by your project. If the application uses native modules, ensure the VPS also has the compiler and system libraries required by the build. Configure the process manager before deploying so a reload task has a known target.
A systemd unit can point at the stable symlink:
[Unit]
Description=My Node application
After=network.target
[Service]
Type=simple
User=app
WorkingDirectory=/var/apps/my-node-app/current
EnvironmentFile=/etc/my-node-app.env
ExecStart=/usr/bin/node server.js
Restart=on-failure
[Install]
WantedBy=multi-user.targetUse the actual Node binary path and entry point for your application. Enable and start the service once, then grant the deploy account only the required restart or reload command if Shipit must invoke it.
Free tools Windows power users keep installed
One-click scans. No signup required.
3. Check repository access
Before the first release, test SSH to the VPS as the deploy account and test repository access using the same credential model that Shipit will use. Private repositories commonly fail because the key authenticates to the VPS but is not authorized to read the Git repository. Separate those two trust relationships: one key or agent for server access and, where appropriate, a deploy key or agent for repository access.
Run the first production deployment
From the project directory, run:
npx shipit production deployThe environment name production selects the production server block, while deploy invokes the deployment task supplied by shipit-deploy. Watch the output for the fetched revision, release path, publication of the current symlink and cleanup result.
Rank #3
- [Low Noise High Fidelity] New bee guitar cord with 22AWG oxygen-free-copper center conductors provides enhanced signal transfer, the PVC insulation material and the high-density stranded copper double shield provide noise rejection for quiet operation
- [Ideal for Choice] New bee 1/4 straight and right angle metal connectors, ensures a secure connection in any instrument, pedal, or amp jack. L shape great fro on stage guitar stands
- [Wide Compatible] Suitable for mixer, power amplifier, microphone, effector, decoder, equalizer, electoronic organ, electric guitar, electric bass and other electronic equipments. Widely used in the installation of smart home, karaoke speaker, professional stage audio, etc
- [Easy Disassemble] Making incidental repairs quick and easy! Very nice, flexible cable
- [Dont Hesite to Order] 24 hours customer services and professional technology team are standing by
Verify the release before calling it live
- On the VPS, confirm that the deployment root contains the expected release directories and that
currentresolves to the newest one. - Check that the service’s working directory is the
currentsymlink, not a timestamped directory. - Inspect service logs and confirm that the process started with the expected Node.js version and environment.
- Request a local or external health endpoint and verify the expected status code and response.
- Only after those checks should you treat the deployment as complete.
Shipit reports task success, not application correctness. A release can publish successfully while a process fails immediately because of a missing environment variable, an incompatible native module or a migration error.
Add dependency, build, migration and health tasks
The deploy plugin provides orchestration and events; it cannot know whether your project needs a build, migrations or a particular restart command. Add tasks that run against current after publication. The following bodies illustrate the required operations; adapt command names and paths to your application.
module.exports = shipit => {
require('shipit-deploy')(shipit)
shipit.initConfig({
default: {
deployTo: '/var/apps/my-node-app',
repositoryUrl: 'https://github.com/example/my-node-app.git',
key: '/home/deploy/.ssh/id_ed25519',
keepReleases: 5,
shallowClone: true
},
production: {
servers: '[email protected]'
}
})
shipit.task('app:install', () => {
const path = `${shipit.config.deployTo}/current`
return shipit.remote(`cd ${path} && npm ci --omit=dev`)
})
shipit.task('app:build', () => {
const path = `${shipit.config.deployTo}/current`
return shipit.remote(`cd ${path} && npm run build`)
})
shipit.task('app:migrate', () => {
const path = `${shipit.config.deployTo}/current`
return shipit.remote(`cd ${path} && npm run migrate`)
})
shipit.task('app:reload', () => {
return shipit.remote('sudo systemctl restart my-node-app.service')
})
shipit.task('app:health', () => {
return shipit.remote('curl --fail --silent --show-error http://127.0.0.1:3000/health')
})
}Use your lockfile’s intended install command. npm ci --omit=dev is appropriate only when the production build has already been produced or when the build does not require development dependencies. If compilation needs devDependencies, install them for the build, run the build, then prune or package the runtime dependencies according to your project’s design.
Put the tasks in a deliberate order
- Install dependencies from the lockfile.
- Build static assets or transpiled code.
- Run a migration plan that is compatible with both the old and new application versions.
- Reload or restart the process manager.
- Run an HTTP health check and fail the deployment if it does not pass.
Shipit’s task and event system lets you attach this sequence to the publication lifecycle. The exact event name and task-composition syntax can vary with the installed ShipitJS and plugin versions, so confirm the API exposed by your locked packages. A common pattern is to start the application task sequence from the plugin’s post-publication event:
shipit.on('published', () => {
shipit.start('app:install', 'app:build', 'app:migrate', 'app:reload', 'app:health')
})If your version does not expose that event or does not run the list sequentially, define a wrapper task that invokes the steps in order and make your CI job call that wrapper. Do not allow a reload to run in parallel with a build or migration.
Make health checks meaningful
A useful endpoint checks more than whether the TCP port is open. Check that the process can load required configuration and reach critical dependencies, but avoid making a health endpoint depend on a slow or destructive operation. Set a timeout, check the expected status code and record the response in deployment logs. For a load-balanced service, drain traffic or use a readiness mechanism before restarting more than one instance.
Choose and configure process supervision
Shipit does not supervise Node.js after the SSH task exits. Use a separate supervisor and call its reload command from the application task.
| Option | What it provides | Shipit integration |
|---|---|---|
| systemd | Operating-system service lifecycle, restart policies, boot integration and journal logs. | Use a restricted systemctl restart or reload command after publication. |
| PM2 | Node-oriented process management, application reloads and its own deployment features. | Shipit can invoke the PM2 command you choose, but PM2 remains a separate component. Its documented SSH deployment form is pm2 deploy <configuration_file> <environment> <command>. |
| Another supervisor | Whatever restart, readiness and logging semantics that tool implements. | Wrap its least-privileged reload command in a Shipit task and follow it with an application health check. |
Do not run two supervisors for the same process. Decide where restart policy, environment loading, log rotation and boot startup are owned, then keep the Shipit task limited to publishing and requesting a controlled reload.
Rank #4
- Digital Family Calendar: BSIMB digital calendar wall touch screen puts an end to your chaotic life. Designed for busy families, the digital calendar keeps you organised and in step with your family. Assign different colours and tasks to each family member to make family scheduling easier and more intuitive.
- Easy Setup and Auto-Sync: Plug in, connect to WLAN and auto-syn your electric calendar in minutes. Digital wall calendar compatible with Google calendar, iCloud calendar, Outlook calendar, Cozi calendar and Yahoo calendar. Add events directly on the device or through the ecalendar app. Electronic calendar stays current whether you're at work or traveling—no manual updates needed.
- All-In-One Home Assistant: Smart calendar builds habits and encourage independence with personalised chores. Display daily meal plan to reduce the daily ‘What's for dinner?’ stress. To-do lists keep track of everything you want. Turning chores into valuable achievements with stars and rewards, making life easier and more enjoyable.
- Manage Anytime Anywhere: BSIMB electronic calendar for family stay connected with the powerful ecalendar app. Access and manage your digital wall calendar anytime, anywhere with free features like stars & rewards, photo screensaver, chore charts, meals plans, to-do lists etc. Electronic planner paid features like Magic Import tailor advanced tools for users with special needs.
- Stay in Touch with Loved Ones: Share photos or videos from your phone to electronic wall calendar with app, instantly update your life moment, and keep in touch with your family, especially those who are far away; you can also surprise your smart calendar digital wall by sending him a wish card; it's also great for keeping tech-illiterate elders in touch with the youngsters.
Roll back safely
When the new release is unhealthy and the previous release is retained, run:
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minutenpx shipit production rollbackThe rollback selects the previous release, repoints current, performs cleanup according to your retention settings and emits rollback lifecycle events. Restart or reload the process after the symlink changes, then run the same health check used for a forward deployment.
Rollback procedure for an incident
- Stop or pause the rollout and capture the failing release identifier and logs.
- Confirm that a known-good release remains within
keepReleases. - Run the rollback command from the same revision of your deployment project.
- Reload the process manager only after the symlink points to the selected release.
- Verify the health endpoint, critical user flow and error rate.
- Record whether the failed release ran any migration or external side effect that needs a separate repair.
The deleteOnRollback setting controls whether the release that was rolled back from is deleted. Keep failed releases while diagnosing an incident unless disk pressure requires removal; deleting evidence too early makes debugging harder.
Test rollback in staging before production. A rollback command can be syntactically successful while the previous binary no longer works with a changed schema, expired credentials or a dependency that has been removed from the server.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Automate deployments from continuous integration
A CI job can run the same command as a workstation:
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallnpx shipit production deployPrepare the runner with the project’s locked Node.js version, install dependencies with the lockfile, inject the SSH key as a secret, and preload the VPS host key. Fail the job on any non-zero Shipit or application-task result. Keep production deployments serialized so two jobs cannot publish and reload different releases at the same time.
CI controls worth adding
- Require a reviewed commit, tag or manually approved revision for production.
- Pass an explicit branch or revision rather than whatever happens to be checked out on a long-lived runner.
- Mask SSH material and remove temporary key files after the job.
- Store the Shipit output, release identifier and health-check response as build artifacts.
- Set a deployment timeout and make a failed health check fail the pipeline.
- Provide a separate rollback job that uses the same SSH trust and configuration.
Security and reliability safeguards
- Least privilege: use a non-root deploy account and narrowly scoped sudo permissions for service control.
- Key hygiene: protect private keys, rotate them, and avoid sharing a personal key with automation.
- Host verification: pin the expected VPS host key in the runner’s known-hosts data.
- Revision control: deploy an intentional commit, branch or tag and record it with the release.
- Lockfile fidelity: install from the lockfile and stop on dependency or build errors.
- Migration safety: make schema changes backward-compatible where possible and document a reversal plan.
- Retention planning: select
keepReleaseswith both rollback needs and available disk capacity in mind. - Observability: inspect process logs, HTTP health, metrics and error reporting after every publication.
- Secret separation: keep runtime secrets out of Git and out of
shipitfile.js.
Troubleshoot the failures you are most likely to see
SSH permission denied or host-key errors
Confirm that the key path is readable by the account running npx shipit, the public key is installed for the intended VPS user and the host key matches the machine you expect. Test with a direct SSH command using the same key and user before changing Shipit settings.
Repository authentication fails
Server access and repository access are different credentials. Verify that the repository URL uses the intended HTTPS token or Git SSH identity, and ensure the key or agent available to the deployment process can read the repository. A key that logs into the VPS does not automatically authorize Git operations.
npm ci or the build fails on the VPS
Compare Node.js and npm versions, confirm that the lockfile matches the package manifest and install required native build tools. If the build needs development dependencies, do not omit them before compilation. Read the first dependency error rather than retrying the same release.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
The symlink changed but the old code still serves traffic
The process manager may still be running a process started from the old directory. Check the service working directory and command line, then run the configured reload or restart task. Follow it with the health check and inspect logs for startup failures.
The migration fails after publication
Do not repeatedly rerun a migration blindly. Determine whether it is transactional, whether it partially changed the schema and whether the application can safely remain on the previous release. Fix the migration or execute its documented repair plan before another publication.
Rollback reports that no usable release exists
Inspect the release directories and retention cleanup. A low keepReleases value, an earlier cleanup or a first deployment may leave no previous release. Increase retention for future deployments and maintain a separately tested recovery path for the initial release.
The VPS runs out of disk space
Measure release directories, package caches and logs. Reduce retention only after confirming that the remaining releases cover your rollback policy, and configure log rotation independently of Shipit’s release cleanup.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Shipit compared with a process manager or another deployment system
These tools solve overlapping but different problems. Compare them on the dimensions that affect your operating model:
| Capability | ShipitJS | PM2 deployment | Generic artifact-based system |
|---|---|---|---|
| SSH and credential handling | Uses SSH configuration, keys and server definitions in Shipit. | Uses the SSH settings in its deployment configuration. | Varies; may use SSH, an agent or a platform API. |
| Release directories and symlinks | Documented release creation, current publication and cleanup. |
Depends on the PM2 deployment configuration and its release behavior. | Depends on the platform or script. |
| Git, rsync or artifact transfer | Documented Git revision fetch and project copy workflow. | Uses PM2’s own deployment mechanism when selected. | Usually transfers a prebuilt artifact. |
| Hook and task extensibility | JavaScript tasks and lifecycle events are central features. | Hooks are available within PM2’s deployment model. | Often pipeline steps or platform hooks. |
| Process supervision | Not included; use systemd, PM2 or another supervisor. | Included as part of PM2’s process-management role. | May be supplied by the platform or left to the host. |
| Release retention and rollback | keepReleases, symlink rollback and deleteOnRollback provide explicit controls. |
Controlled by PM2’s deployment configuration and retained files. | Depends on artifact and platform policy. |
| CI integration | Invoke the CLI from a pipeline and secure its SSH key. | Invoke PM2’s deployment command from a pipeline. | Usually a first-class pipeline feature. |
Choose Shipit when you want JavaScript-defined SSH automation and control over the release lifecycle, while retaining your own choice of process supervisor. Choose a process manager’s deployment feature when its application lifecycle and deployment configuration already match your operations. In either case, insist on immutable releases, explicit health checks and a tested rollback path.
Production deployment checklist
- Install and lock
shipit-cliandshipit-deployas development dependencies. - Create a non-root VPS deploy account and verify SSH host keys.
- Install the required Node.js runtime, npm and build libraries.
- Configure the process supervisor and its environment file.
- Set
deployTo,repositoryUrl,servers,key,keepReleasesandshallowClone. - Deploy an intentional revision with
npx shipit production deploy. - Run locked dependency installation, build and migration tasks in sequence.
- Switch or reload the process only after the release is complete.
- Fail the deployment when the HTTP health check fails.
- Confirm that multiple releases remain and test
npx shipit production rollbackin staging. - Monitor logs, metrics and disk usage after publication.
The practical outcome
A reliable ShipitJS setup is a small release system rather than a single deployment command: the CLI and plugin publish versioned directories, the current symlink provides an atomic target, your tasks install and validate the application, and a separate supervisor keeps Node.js running. Once SSH credentials, retention, health checks and rollback have been tested, the same workflow can be run by a developer or CI without changing the production procedure.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →
