rollbridge 0.1.1

package/AI_TODO_PROMPT.md

@@ -0,0 +1,39 @@
+# AI Prompt For Rollbridge TODO Work
+
+Use this prompt when asking an AI agent to implement one or more isolated Rollbridge TODO items.
+
+```text
+You are working in the Rollbridge repository.
+
+Goal:
+Pick one or more isolated unchecked items from TODO.md and implement them end to end. Prefer one focused item unless several TODOs are tightly coupled and can be completed cleanly in the same change.
+
+Before changing files:
+1. Read README.md, TODO.md, package.json, and the source files related to the chosen TODO item.
+2. State the exact TODO item(s) you are taking.
+3. Confirm the item is isolated. Do not combine unrelated roadmap items.
+
+Scope rules:
+- Keep the diff focused on the selected TODO item(s).
+- Do not add Capistrano plugins, Capistrano tasks, or Capistrano-specific integration code. Deploy tools should call Rollbridge through CLI commands.
+- Capistrano documentation examples are allowed only as shell-command recipes that invoke Rollbridge CLI commands.
+- Do not change runtime behavior for documentation-only TODOs.
+- Do not mark a TODO checkbox complete unless the feature or document is actually finished and validated.
+- If the work changes public config, CLI output, command names, or operational behavior, update README.md or dedicated docs in the same change.
+
+Implementation expectations:
+- Follow existing Rollbridge patterns and JSDoc style.
+- Keep config validation at the boundary and trust normalized config downstream.
+- Add behavior-focused tests for new process, daemon, CLI, config, or proxy behavior.
+- For worker or memory supervision work, include status output and tests covering failure/restart behavior.
+- For docs work, include concrete commands and examples that an operator can use.
+
+Suggested acceptance criteria:
+- The selected TODO item(s) are implemented or documented fully.
+- Relevant TODO.md checkbox(es) are updated.
+- npm run all-checks passes.
+- The final response summarizes changed behavior, docs, tests, and any remaining follow-up work.
+
+If the TODO item is too large:
+Split it into a smaller independently shippable subtask, document the boundary in TODO.md, and implement only that subtask.
+```

package/README.md

@@ -0,0 +1,200 @@
+# Rollbridge
+
+Rollbridge is a Node.js process supervisor and local traffic switcher for zero-downtime deploys.
+
+Nginx points at one stable Rollbridge proxy port. Deploy tooling asks Rollbridge to start a new release, health-check it, switch new traffic to it, and drain old HTTP/WebSocket connections before stopping the previous release.
+
+## Install
+
+```bash
+npm install rollbridge
+```
+
+For local development in this repository:
+
+```bash
+npm install
+npm run all-checks
+```
+
+## Config
+
+A Rollbridge config is a JavaScript module that `export default`s a config
+object. It can also export a function (sync or async) that returns the object,
+which is handy for computing values from the environment. Write it in your
+project's module system — `export default` for ESM (`"type": "module"`) or
+`module.exports` for CommonJS.
+
+```js
+// rollbridge.js
+export default {
+  application: "ticket-server",
+
+  control: {
+    path: "/tmp/rollbridge-ticket-server.sock"
+  },
+
+  proxy: {
+    host: "127.0.0.1",
+    port: 8182,
+    healthPath: "/ping",
+    healthTimeoutMs: 30000,
+    drainTimeoutMs: 60000,
+    forceStopTimeoutMs: 10000
+  },
+
+  processes: [
+    {
+      id: "beacon",
+      policy: "companion",
+      cwd: "{{releasePath}}",
+      command: "env VELOCIOUS_BEACON_PORT={{port}} npx velocious beacon",
+      port: {from: 17330, to: 17399}
+    },
+    {
+      id: "background-jobs-worker",
+      policy: "companion",
+      cwd: "{{releasePath}}",
+      command: "npx velocious background-jobs-worker"
+    },
+    {
+      id: "background-jobs-main",
+      policy: "service",
+      cwd: "{{releasePath}}",
+      command: "npx velocious background-jobs-main"
+    },
+    {
+      id: "web",
+      policy: "proxied",
+      cwd: "{{releasePath}}",
+      command: "npx velocious server --host 127.0.0.1 --port {{port}}",
+      port: {from: 18182, to: 18299},
+      health: {path: "/ping", timeoutMs: 30000}
+    }
+  ]
+}
+```
+
+A function export receives no arguments and lets you build the config at load
+time:
+
+```js
+// rollbridge.js
+export default () => ({
+  application: process.env.APP_NAME || "ticket-server",
+  control: {path: `/tmp/rollbridge-${process.env.APP_NAME || "ticket-server"}.sock`},
+  proxy: {host: "127.0.0.1", port: 8182},
+  processes: [
+    {id: "web", policy: "proxied", cwd: "{{releasePath}}", command: "npx velocious server --port {{port}}", port: {from: 18182, to: 18299}}
+  ]
+})
+```
+
+Production-ready examples live in `examples/`, including
+`examples/tensorbuzz.com.js` for the current TensorBuzz backend deployment.
+
+## Process Policies
+
+- `proxied`: the web/API process. Rollbridge forwards HTTP and WebSocket traffic to the active release and tracks connections for draining.
+- `companion`: a release-scoped support process. It starts with the release and stops after that release drains.
+- `singleton`: a one-at-a-time support process. Rollbridge stops the old singleton before starting the new one, so duplicate-unsafe schedulers or job dispatchers do not overlap.
+- `service`: a daemon-wide support process. Rollbridge starts it before release processes need it, leaves it running across deploys, and updates its restart template after a successful deploy.
+
+## Commands
+
+`--config` is optional for every command. When omitted, Rollbridge looks for
+`rollbridge.js` in the current directory. The examples below pass `--config`
+explicitly, but `rollbridge validate` (or any command) works with no flag when a
+`rollbridge.js` is present.
+
+Validate a config without starting the daemon:
+
+```bash
+rollbridge validate --config rollbridge.js
+```
+
+`validate` reports every config error at once with an example fix and exits
+non-zero when issues are found, so deploy tooling can gate on it. It checks
+required fields and types, duplicate process IDs, port ranges, that exactly one
+process is `proxied`, and that the proxied process defines a port range. Example
+output for a misconfigured file:
+
+```text
+Found 2 configuration issues in rollbridge.js:
+
+1. Config must define exactly one proxied process; found 0
+   Fix: Mark exactly one process with policy: proxied so Rollbridge knows where to forward traffic.
+
+2. Duplicate process id: web
+   Fix: Give each process a unique id; "web" is used more than once.
+```
+
+Start the daemon:
+
+```bash
+rollbridge daemon --config rollbridge.js
+```
+
+Start the daemon only when it is not already running:
+
+```bash
+rollbridge ensure-daemon --config rollbridge.js --daemon-log-path log/rollbridge.log --daemon-pid-path tmp/pids/rollbridge.pid
+```
+
+Deploy a prepared release:
+
+```bash
+rollbridge deploy --config rollbridge.js --release-path /home/dev/ticket-server/releases/20260521073000/ticket-server --revision abc123
+```
+
+Deploy and start the daemon first when needed:
+
+```bash
+rollbridge deploy --ensure-daemon --config rollbridge.js --release-path /home/dev/ticket-server/releases/20260521073000/ticket-server --revision abc123
+```
+
+Inspect state:
+
+```bash
+rollbridge status --config rollbridge.js
+```
+
+Stop the active release:
+
+```bash
+rollbridge stop --config rollbridge.js
+```
+
+Shut down the daemon and managed processes:
+
+```bash
+rollbridge shutdown --config rollbridge.js
+```
+
+## Nginx
+
+Nginx should proxy to Rollbridge, not directly to Velocious:
+
+```nginx
+location / {
+  proxy_pass http://127.0.0.1:8182;
+  proxy_http_version 1.1;
+  proxy_set_header Upgrade $http_upgrade;
+  proxy_set_header Connection "upgrade";
+  proxy_set_header Host $host;
+  proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+  proxy_set_header X-Forwarded-Proto $scheme;
+}
+```
+
+## Deployment Notes
+
+Run migrations before `rollbridge deploy`, and keep migrations backwards-compatible while old and new web releases overlap. For stable local brokers such as Velocious Beacon or `background-jobs-main`, use `service` when the process should survive deploys and restart from the latest successful release if it crashes.
+
+## Releasing
+
+Maintainers can publish a patch release from the latest default branch:
+
+```bash
+npm run release:patch
+```

package/TODO.md

@@ -0,0 +1,96 @@
+# Rollbridge TODO
+
+This roadmap tracks planned Rollbridge features and documentation. Rollbridge should stay deploy-tool agnostic: Capistrano, shell scripts, CI, or other deploy systems should call Rollbridge through CLI commands instead of Rollbridge shipping Capistrano tasks or plugins.
+
+## Current Baseline
+
+- [x] Stable local HTTP/WebSocket proxy in front of one active release.
+- [x] Unix socket control API used by the CLI.
+- [x] `daemon`, `ensure-daemon`, `deploy`, `status`, `stop`, and `shutdown` commands.
+- [x] Per-release process startup with templated `releasePath`, `releaseId`, `revision`, and ports.
+- [x] Process policies for `proxied`, `companion`, `singleton`, and `service`.
+- [x] HTTP health check before switching traffic to a new web process.
+- [x] Drain old HTTP/WebSocket connections before stopping previous release processes.
+- [x] Restart crashed active release processes after `restartDelayMs`.
+- [x] Restart crashed daemon-wide service processes from the latest successful release template.
+- [x] Graceful `SIGTERM` followed by `SIGKILL` after timeout.
+- [x] TensorBuzz production example config.
+- [x] ESLint, TypeScript `checkJs`, TensorBuzz CI, and `release:patch`.
+
+## Major Features
+
+- [ ] Memory supervision.
+  - [ ] Add per-process memory config with an RSS limit, check interval, warning threshold, and restart policy.
+  - [ ] Measure the managed process tree, not only the shell wrapper PID.
+  - [ ] Report memory stats and last memory-triggered restart in `status`.
+  - [ ] Restart memory-heavy workers gracefully when possible, with a forced stop timeout.
+  - [ ] Add tests with a fixture process that allocates memory above the configured limit.
+- [ ] Worker auto-restart and restart policy controls.
+  - [ ] Add config for max restarts, restart window, exponential backoff, and disabled restart behavior.
+  - [ ] Distinguish crash restarts, deploy replacements, manual restarts, and memory restarts in status/events.
+  - [ ] Add a `restart` CLI command for a single process, a policy group, or all non-proxied workers.
+  - [ ] Keep restart behavior safe for job workers by using lifecycle hooks before termination.
+- [ ] Graceful job-worker lifecycle.
+  - [ ] Add generic lifecycle hooks such as `quietCommand`, `drainCommand`, `drainTimeoutMs`, and `stopCommand`.
+  - [ ] Support signal-only lifecycle steps for workers that can quiet on a Unix signal.
+  - [ ] Add a non-blocking drain mode so new workers can start while old workers finish running jobs.
+  - [ ] Document a Velocious background-jobs-worker recipe once the lifecycle contract is implemented.
+- [ ] Replicas and stable worker indexes.
+  - [ ] Allow one process config to start multiple replicas.
+  - [ ] Expose `ROLLBRIDGE_REPLICA_INDEX`, replica count, and per-replica template context.
+  - [ ] Restart or stop one replica without affecting the rest.
+  - [ ] Preserve readable status output for replica groups.
+- [ ] Persistent daemon state and recovery.
+  - [ ] Persist active release, draining releases, process metadata, counters, and recent events.
+  - [ ] Reconnect status to still-running child processes after daemon restart where possible.
+  - [ ] Detect and report orphaned Rollbridge-managed processes.
+  - [ ] Add a recovery mode for safe startup after daemon crash or machine reboot.
+- [ ] Rollback support.
+  - [ ] Keep enough release metadata to switch traffic back to a previous healthy release.
+  - [ ] Add a `rollback` CLI command that health-checks the target before switching.
+  - [ ] Define how rollback interacts with singleton workers and draining releases.
+  - [ ] Document migration constraints for rollback.
+- [ ] Observability and diagnostics.
+  - [ ] Add structured event history for deploys, switches, stops, crashes, memory restarts, and failed commands.
+  - [ ] Add restart counters, uptime, exit reasons, memory stats, and child-process-tree details to status.
+  - [ ] Add `logs` and `events` CLI commands.
+  - [ ] Add optional file logging with rotation guidance.
+  - [ ] Add machine-readable JSON output flags for all CLI commands.
+- [ ] Config validation and doctoring.
+  - [x] Add `validate` to parse config and report all config errors without starting the daemon.
+  - [ ] Add `doctor` to check control socket reachability, proxy port availability, process commands, release path, and writable log/state paths.
+  - [x] Validate duplicate process IDs, missing ports on proxied processes, invalid ranges, and the single-proxied-process policy rule.
+  - [ ] Validate unsupported lifecycle-hook combinations once worker lifecycle hooks land.
+  - [x] Include example fixes in validation output.
+
+## Minor Features
+
+- [ ] Add socket permission and socket owner/group options for shared deploy users.
+- [x] Make stale control socket diagnostics clearer when another daemon is still alive.
+- [ ] Add old-release cleanup policies by age, count, and stopped state.
+- [x] Add port allocation diagnostics when a range is exhausted.
+- [ ] Add optional startup command timeout before health checks begin.
+- [ ] Add process output retention config instead of a fixed recent-log count.
+- [ ] Add environment variable interpolation from the daemon environment.
+- [x] Add `--config` default lookup resolving to `rollbridge.js` when no path is given.
+- [ ] Add shell completion generation for common shells.
+- [ ] Add npm package metadata such as repository, license, bugs, and homepage.
+- [ ] Add systemd service examples for the Rollbridge daemon.
+- [ ] Add tests for malformed control socket JSON and unknown control commands.
+- [ ] Add tests for duplicate IDs and singleton replacement failure behavior.
+- [ ] Add tests for proxy behavior when the active release exits unexpectedly.
+
+## Documentation TODO
+
+- [ ] Write a full config reference covering every field, default, and template variable.
+- [ ] Write a CLI reference for `daemon`, `ensure-daemon`, `deploy`, `status`, `stop`, `shutdown`, and future commands.
+- [ ] Expand process policy docs with deployment examples for `proxied`, `companion`, `singleton`, and `service`.
+- [ ] Document memory checks and auto-restart behavior after the feature lands.
+- [ ] Document worker lifecycle hooks and safe background-job deployment patterns after the feature lands.
+- [ ] Add a Velocious deployment guide with Beacon, background-jobs-main, background-jobs-worker, and web process examples.
+- [ ] Add an Nginx guide with WebSocket headers, timeouts, and common failure modes.
+- [ ] Add deploy-tool recipes that call Rollbridge CLI commands directly.
+- [ ] Add a Capistrano recipe showing shell commands only; do not add a Capistrano plugin or Rollbridge-specific Capistrano tasks.
+- [ ] Add a TensorBuzz-specific runbook for current production ports, external services, deploy ordering, and rollback constraints.
+- [ ] Add troubleshooting docs for health-check failures, port conflicts, stale sockets, crash loops, and stuck draining releases.
+- [ ] Add a release checklist for maintainers using `npm run release:patch`.

package/bin/rollbridge

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import {runCli} from "../src/cli.js"
+
+await runCli(process.argv)

package/eslint.config.js

@@ -0,0 +1,99 @@
+import js from "@eslint/js"
+import {jsdoc} from 'eslint-plugin-jsdoc'
+import globals from "globals"
+import { defineConfig } from "eslint/config"
+
+/**
+ * Extracts the brace-balanced type expressions that follow JSDoc tags in a comment body.
+ * @param {string} commentValue The raw comment text between the comment delimiters.
+ * @returns {string[]} Each `{...}` type expression, without its surrounding braces.
+ */
+function jsdocTypeExpressions(commentValue) {
+  const types = []
+  const tagWithType = /@\w+\s*\{/g
+  let match
+
+  while ((match = tagWithType.exec(commentValue))) {
+    let depth = 0
+    let start = -1
+
+    for (let index = match.index + match[0].length - 1; index < commentValue.length; index++) {
+      const character = commentValue[index]
+
+      if (character === "{") {
+        if (depth === 0) start = index
+        depth++
+      } else if (character === "}") {
+        depth--
+
+        if (depth === 0) {
+          types.push(commentValue.slice(start + 1, index))
+          break
+        }
+      }
+    }
+  }
+
+  return types
+}
+
+// eslint-plugin-jsdoc rejects `any` everywhere (jsdoc/reject-any-type) but only catches `unknown`
+// at the top level, so this local rule rejects `unknown` anywhere inside a JSDoc type expression.
+const localPlugin = {
+  rules: {
+    "no-unknown-jsdoc-type": {
+      meta: {
+        type: "problem",
+        docs: {description: "Disallow the `unknown` type anywhere in JSDoc type annotations."},
+        messages: {noUnknown: "Avoid the unknown type in JSDoc; use a specific type such as JsonValue (src/json.d.ts) instead."},
+        schema: []
+      },
+      create(context) {
+        return {
+          Program() {
+            for (const comment of context.sourceCode.getAllComments()) {
+              if (comment.type !== "Block" || !comment.value.startsWith("*")) continue
+
+              const hasUnknown = jsdocTypeExpressions(comment.value).some((type) => /\bunknown\b/.test(type))
+
+              if (hasUnknown) context.report({loc: comment.loc, messageId: "noUnknown"})
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+export default defineConfig([
+  {
+    name: "global ignores",
+    ignores: ["build/**", "dist/**"],
+  },
+  {
+    files: ["**/*.{js,mjs,cjs}", "**/bin/rollbridge"],
+    plugins: {js},
+    extends: ["js/recommended"],
+    languageOptions: {
+      globals: {...globals.browser, ...globals.node}
+    },
+    rules: {
+      "no-unused-vars": ["error", {argsIgnorePattern: "^_", varsIgnorePattern: "^_", caughtErrorsIgnorePattern: "^_"}]
+    }
+  },
+  jsdoc({
+    config: "flat/recommended",
+    files: ["**/*.{js,mjs,cjs}", "**/bin/rollbridge"],
+    rules: {
+      "jsdoc/reject-any-type": "error"
+    }
+  }),
+  {
+    name: "local jsdoc type rules",
+    files: ["**/*.{js,mjs,cjs}", "**/bin/rollbridge"],
+    plugins: {local: localPlugin},
+    rules: {
+      "local/no-unknown-jsdoc-type": "error"
+    }
+  }
+])

package/examples/tensorbuzz.com.js

@@ -0,0 +1,85 @@
+// Rollbridge config for the TensorBuzz production backend.
+//
+// Nginx should keep proxying the backend host to 127.0.0.1:4500. Rollbridge
+// binds that stable HTTP port, forwards to the active release's internal web
+// port, keeps Beacon/jobs-main as daemon-wide services, and starts one
+// background worker per active release.
+
+export default {
+  application: "tensorbuzz",
+
+  control: {
+    path: "/tmp/rollbridge-tensorbuzz.sock"
+  },
+
+  proxy: {
+    host: "127.0.0.1",
+    port: 4500,
+    healthPath: "/ping",
+    healthTimeoutMs: 30000,
+    drainTimeoutMs: 60000,
+    forceStopTimeoutMs: 10000
+  },
+
+  processes: [
+    {
+      id: "beacon",
+      policy: "service",
+      cwd: "{{releasePath}}/backend",
+      env: {
+        NODE_ENV: "production",
+        VELOCIOUS_ENV: "production",
+        VELOCIOUS_BEACON_PORT: "{{port}}"
+      },
+      command: "npx velocious beacon",
+      port: 7330
+    },
+    {
+      id: "background-jobs-main",
+      policy: "service",
+      cwd: "{{releasePath}}/backend",
+      env: {
+        NODE_ENV: "production",
+        VELOCIOUS_ENV: "production",
+        VELOCIOUS_BEACON_PORT: "{{ports.beacon}}",
+        VELOCIOUS_BACKGROUND_JOBS_PORT: "{{port}}"
+      },
+      command: "wait-for-it 127.0.0.1:{{ports.beacon}} --strict -- npx velocious background-jobs-main",
+      port: 7331
+    },
+    {
+      id: "background-jobs-worker",
+      policy: "companion",
+      cwd: "{{releasePath}}/backend",
+      env: {
+        NODE_ENV: "production",
+        VELOCIOUS_ENV: "production",
+        VELOCIOUS_BEACON_PORT: "{{ports.beacon}}",
+        VELOCIOUS_BACKGROUND_JOBS_PORT: "{{ports.background-jobs-main}}"
+      },
+      command: "wait-for-it 127.0.0.1:{{ports.beacon}} --strict -- wait-for-it 127.0.0.1:{{ports.background-jobs-main}} --strict -- npx velocious background-jobs-worker",
+      gracefulStopMs: 60000
+    },
+    {
+      id: "web",
+      policy: "proxied",
+      cwd: "{{releasePath}}/backend",
+      env: {
+        NODE_ENV: "production",
+        VELOCIOUS_ENV: "production",
+        VELOCIOUS_BEACON_PORT: "{{ports.beacon}}",
+        VELOCIOUS_BACKGROUND_JOBS_PORT: "{{ports.background-jobs-main}}"
+      },
+      command: "wait-for-it 127.0.0.1:{{ports.beacon}} --strict -- wait-for-it 127.0.0.1:{{ports.background-jobs-main}} --strict -- npx velocious server --host 127.0.0.1 --port {{port}}",
+      port: {
+        from: 14500,
+        to: 14599
+      },
+      health: {
+        path: "/ping",
+        timeoutMs: 30000,
+        intervalMs: 500
+      }
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "rollbridge",
+  "version": "0.1.1",
+  "description": "Zero-downtime process supervisor and local traffic switcher for deploy-managed apps.",
+  "type": "module",
+  "bin": {
+    "rollbridge": "./bin/rollbridge"
+  },
+  "scripts": {
+    "all-checks": "npm run typecheck && npm run lint && npm test",
+    "lint": "eslint",
+    "release:patch": "node scripts/release-patch.js",
+    "test": "node --test test/*.test.js",
+    "typecheck": "tsc --noEmit"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "http-proxy": "^1.18.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/http-proxy": "^1.17.17",
+    "@types/node": "^25.9.1",
+    "eslint": "^10.4.0",
+    "eslint-plugin-jsdoc": "^62.9.0",
+    "globals": "^17.6.0",
+    "typescript": "^6.0.3"
+  }
+}

package/scripts/release-patch.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import {execFileSync} from "node:child_process"
+
+/**
+ * Runs a command and inherits stdio.
+ * @param {string} command - Command to run.
+ * @param {string[]} [args] - Command arguments.
+ * @returns {void}
+ */
+function run(command, args = []) {
+  execFileSync(command, args, {
+    env: {
+      ...process.env,
+      GIT_EDITOR: "true",
+      GIT_MERGE_AUTOEDIT: "no"
+    },
+    stdio: "inherit"
+  })
+}
+
+/**
+ * Runs a command and returns trimmed stdout.
+ * @param {string} command - Command to run.
+ * @param {string[]} [args] - Command arguments.
+ * @returns {string} Trimmed stdout.
+ */
+function output(command, args = []) {
+  return execFileSync(command, args, {encoding: "utf8"}).trim()
+}
+
+/** @returns {string} GitHub remote default branch name. */
+function defaultBranch() {
+  const remoteHead = output("git", ["ls-remote", "--symref", "origin", "HEAD"])
+  const match = remoteHead.match(/^ref: refs\/heads\/(.+)\s+HEAD$/m)
+
+  if (!match) throw new Error("Unable to determine origin default branch")
+
+  return match[1]
+}
+
+/**
+ * @param {string} branch - Branch name.
+ * @returns {boolean} True when the local branch exists.
+ */
+function localBranchExists(branch) {
+  try {
+    output("git", ["rev-parse", "--verify", `refs/heads/${branch}`])
+    return true
+  } catch (_error) {
+    return false
+  }
+}
+
+/** @returns {string} Updated default branch name. */
+function updateLocalDefaultBranch() {
+  run("git", ["fetch", "origin"])
+  const branch = defaultBranch()
+
+  if (localBranchExists(branch)) {
+    run("git", ["checkout", branch])
+  } else {
+    run("git", ["checkout", "-b", branch, `origin/${branch}`])
+  }
+
+  run("git", ["merge", "--ff-only", `origin/${branch}`])
+
+  return branch
+}
+
+try {
+  execFileSync("npm", ["whoami"], {stdio: "ignore"})
+} catch {
+  run("npm", ["login"])
+}
+
+const branch = updateLocalDefaultBranch()
+
+run("npm", ["version", "patch", "--no-git-tag-version"])
+run("npm", ["install"])
+run("git", ["add", "package.json", "package-lock.json"])
+run("git", ["commit", "-m", "chore: bump patch version"])
+run("git", ["push", "origin", branch])
+run("npm", ["publish"])