rollbridge 0.1.2 → 0.1.5

package/test/release-retention.test.js

@@ -0,0 +1,107 @@
+// @ts-check
+
+import assert from "node:assert/strict"
+import fs from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import test from "node:test"
+import {fileURLToPath} from "node:url"
+import RollbridgeDaemon, {releasesToPrune} from "../src/daemon.js"
+import {normalizeConfig} from "../src/config.js"
+
+const currentDir = path.dirname(fileURLToPath(import.meta.url))
+const dummyAppPath = path.join(currentDir, "fixtures", "dummy-app.js")
+
+test("releasesToPrune keeps the most recent stopped releases and never active or draining ones", () => {
+  const releases = [
+    {releaseId: "active", state: "active", stoppedAt: undefined},
+    {releaseId: "draining", state: "draining", stoppedAt: undefined},
+    {releaseId: "v3", state: "stopped", stoppedAt: "2026-05-22T00:00:03.000Z"},
+    {releaseId: "v2", state: "stopped", stoppedAt: "2026-05-22T00:00:02.000Z"},
+    {releaseId: "v1", state: "stopped", stoppedAt: "2026-05-22T00:00:01.000Z"}
+  ]
+
+  const remove = releasesToPrune(releases, {keep: 1, maxAgeMs: 0}, Date.parse("2026-05-22T00:00:10.000Z"))
+
+  assert.deepEqual([...remove].sort(), ["v1", "v2"])
+})
+
+test("releasesToPrune keeps the later-deployed release when stoppedAt ties", () => {
+  const sameTime = "2026-05-22T00:00:05.000Z"
+  // Deploy order (oldest first): v1 then v2, both stopped in the same millisecond.
+  const releases = [
+    {releaseId: "v1", state: "stopped", stoppedAt: sameTime},
+    {releaseId: "v2", state: "stopped", stoppedAt: sameTime}
+  ]
+
+  const remove = releasesToPrune(releases, {keep: 1, maxAgeMs: 0}, Date.parse("2026-05-22T00:00:10.000Z"))
+
+  assert.deepEqual(remove, ["v1"])
+})
+
+test("releasesToPrune prunes stopped releases older than maxAgeMs", () => {
+  const now = Date.parse("2026-05-22T00:01:00.000Z")
+  const releases = [
+    {releaseId: "fresh", state: "stopped", stoppedAt: new Date(now - 1000).toISOString()},
+    {releaseId: "old", state: "stopped", stoppedAt: new Date(now - 60000).toISOString()}
+  ]
+
+  const remove = releasesToPrune(releases, {keep: 100, maxAgeMs: 30000}, now)
+
+  assert.deepEqual(remove, ["old"])
+})
+
+test("the daemon prunes stopped releases beyond the retention count across deploys", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-retention-"))
+  const config = normalizeConfig({
+    application: "rollbridge-retention-test",
+    control: {path: path.join(root, "rollbridge.sock")},
+    processes: [
+      {
+        command: `${JSON.stringify(process.execPath)} ${JSON.stringify(dummyAppPath)}`,
+        health: {intervalMs: 50, path: "/ping", timeoutMs: 3000},
+        id: "web",
+        policy: "proxied",
+        port: {from: 0, to: 0}
+      }
+    ],
+    proxy: {drainTimeoutMs: 200, forceStopTimeoutMs: 200, host: "127.0.0.1", port: 0},
+    releaseRetention: {keep: 1}
+  })
+  const daemon = new RollbridgeDaemon({config, logger: () => {}})
+
+  await daemon.start()
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: root, revision: "v1"})
+    await daemon.deploy({releaseId: "v2", releasePath: root, revision: "v2"})
+    await daemon.deploy({releaseId: "v3", releasePath: root, revision: "v3"})
+
+    // Older stopped releases are pruned once they drain; keep:1 retains only the most recent stopped one.
+    await waitFor(() => !daemon.status().releases.some((release) => release.releaseId === "v1"))
+
+    const ids = daemon.status().releases.map((release) => release.releaseId)
+
+    assert.ok(ids.includes("v3"), `active release should be retained, got ${JSON.stringify(ids)}`)
+    assert.ok(!ids.includes("v1"), `oldest stopped release should be pruned, got ${JSON.stringify(ids)}`)
+    assert.ok(ids.length <= 2, `expected at most the active release plus one stopped, got ${JSON.stringify(ids)}`)
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(root, {force: true, recursive: true})
+  }
+})
+
+/**
+ * @param {() => boolean} callback - Probe.
+ * @returns {Promise<void>} Resolves once the probe returns true.
+ */
+async function waitFor(callback) {
+  const deadline = Date.now() + 3000
+
+  while (Date.now() < deadline) {
+    if (callback()) return
+    await new Promise((resolve) => setTimeout(resolve, 25))
+  }
+
+  throw new Error("Timed out waiting for condition")
+}

package/test/rollbridge.test.js

@@ -64,6 +64,57 @@ test("failed health check leaves the previous release active", async () => {
   }
 })
 
+test("wildcard proxy bind host targets release processes through loopback", async () => {
+  const fixture = await createFixture({proxyHost: "0.0.0.0"})
+  const daemon = await startDaemon(fixture.config)
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+
+    const status = daemon.status()
+    const release = statusRelease(daemon, "v1")
+
+    assert.ok(daemon.activeRelease, "expected active release")
+    assert.equal(status.proxy.host, "0.0.0.0")
+    assert.equal(status.proxy.upstreamHost, "127.0.0.1")
+    assert.equal(daemon.activeRelease.proxyTarget().target, `http://127.0.0.1:${release.ports.web}`)
+    assert.equal(await fetchText(daemon, "/release"), "v1")
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("failed release startup logs process output before cleanup", async () => {
+  const fixture = await createFixture({webCommand: `${JSON.stringify(process.execPath)} -e "console.log('startup stdout'); console.error('startup stderr'); const http = require('node:http'); http.createServer((_request, response) => { response.writeHead(500); response.end('bad') }).listen(Number(process.env.ROLLBRIDGE_PORT), '127.0.0.1')"`, webHealthTimeoutMs: 500})
+  /** @type {Array<{data?: Record<string, import("../src/json.js").JsonValue>, message: string}>} */
+  const logs = []
+  const daemon = new RollbridgeDaemon({
+    config: fixture.config,
+    logger: (message, data = {}) => logs.push({data, message})
+  })
+
+  await daemon.start()
+
+  try {
+    await assert.rejects(
+      () => daemon.deploy({releaseId: "bad", releasePath: fixture.root, revision: "bad"}),
+      /Health check failed/
+    )
+
+    const processStatusLog = logs.find((entry) => entry.message === "release startup process status" && entry.data?.processId === "web")
+
+    assert.ok(processStatusLog, "expected failed web process diagnostics to be logged")
+    assert.ok(processStatusLog.data, "expected diagnostic data")
+    assert.ok(Array.isArray(processStatusLog.data.logs), "expected retained process output in diagnostics")
+    assert.ok(processStatusLog.data.logs.some((entry) => typeof entry === "object" && entry && "line" in entry && entry.line === "startup stdout"))
+    assert.ok(processStatusLog.data.logs.some((entry) => typeof entry === "object" && entry && "line" in entry && entry.line === "startup stderr"))
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
 test("singleton processes restart without overlap during deploy", async () => {
   const fixture = await createFixture({includeSingleton: true})
   const daemon = await startDaemon(fixture.config)
@@ -90,6 +141,38 @@ test("singleton processes restart without overlap during deploy", async () => {
   }
 })
 
+test("a failed singleton replacement surfaces the error after stopping the old singleton", async () => {
+  // The singleton's working directory is per-release; only the v1 directory exists, so
+  // the v2 replacement cannot spawn (ENOENT on cwd) and its start() rejects.
+  const fixture = await createFixture({includeSingleton: true, singletonCwd: "{{releasePath}}/{{releaseId}}"})
+  const daemon = await startDaemon(fixture.config)
+
+  await fs.mkdir(path.join(fixture.root, "v1"))
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+    await waitFor(async () => (await processEvents(fixture.singletonLogPath)).some((event) => event.event === "start" && event.releaseId === "v1"))
+
+    // The new release's singleton fails to start, so the deploy surfaces the error.
+    await assert.rejects(() => daemon.deploy({releaseId: "v2", releasePath: fixture.root, revision: "v2"}))
+
+    // The old singleton is stopped before the new one is started, so two copies never
+    // overlap — even when the replacement then fails.
+    await waitFor(async () => (await processEvents(fixture.singletonLogPath)).some((event) => event.event === "stop" && event.releaseId === "v1"))
+
+    const status = daemon.status()
+
+    // Traffic switches before singletons are replaced, so the new release is already active,
+    // but its singleton is left failed with no replacement running.
+    assert.equal(status.activeReleaseId, "v2")
+    assert.equal(status.singletons.length, 1)
+    assert.equal(status.singletons[0].process.state, "failed")
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
 test("service processes start before releases and restart with the latest deploy template", async () => {
   const fixture = await createFixture({includeService: true, webDependsOnService: true})
   const daemon = await startDaemon(fixture.config)
@@ -122,6 +205,137 @@ test("service processes start before releases and restart with the latest deploy
   }
 })
 
+test("restart bounces a single process by id", async () => {
+  const fixture = await createFixture({includeService: true})
+  const daemon = await startDaemon(fixture.config)
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+
+    const before = pidsById(daemon.status())
+    const result = await daemon.restartProcesses({processId: "beacon"})
+
+    assert.deepEqual(result.restarted, ["beacon"])
+
+    const after = pidsById(daemon.status())
+
+    assert.ok(before.beacon && after.beacon, "beacon should have a pid before and after")
+    assert.notEqual(after.beacon, before.beacon)
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("restart with no selector bounces every non-proxied process but not the proxied one", async () => {
+  const fixture = await createFixture({includeCompanion: true, includeService: true, includeSingleton: true})
+  const daemon = await startDaemon(fixture.config)
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+
+    const before = pidsById(daemon.status())
+    const result = await daemon.restartProcesses()
+    const restarted = /** @type {string[]} */ (result.restarted)
+
+    assert.deepEqual([...restarted].sort(), ["beacon", "jobs-main", "worker"])
+
+    const after = pidsById(daemon.status())
+
+    assert.equal(after.web, before.web, "proxied process should not be restarted")
+    assert.notEqual(after.beacon, before.beacon)
+    assert.notEqual(after["jobs-main"], before["jobs-main"])
+    assert.notEqual(after.worker, before.worker)
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("restart --policy targets only processes with that policy", async () => {
+  const fixture = await createFixture({includeCompanion: true, includeService: true})
+  const daemon = await startDaemon(fixture.config)
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+
+    const before = pidsById(daemon.status())
+    const result = await daemon.restartProcesses({policy: "companion"})
+
+    assert.deepEqual(result.restarted, ["worker"])
+
+    const after = pidsById(daemon.status())
+
+    assert.notEqual(after.worker, before.worker)
+    assert.equal(after.beacon, before.beacon, "the service should be left running")
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("restart refuses the proxied process and reports unknown ids", async () => {
+  const fixture = await createFixture()
+  const daemon = await startDaemon(fixture.config)
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+
+    await assert.rejects(() => daemon.restartProcesses({processId: "web"}), /proxied process cannot be restarted/)
+    await assert.rejects(() => daemon.restartProcesses({policy: "proxied"}), /proxied process cannot be restarted/)
+    await assert.rejects(() => daemon.restartProcesses({processId: "missing"}), /No managed process with id "missing"/)
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("restart revives a stopped process instead of erroring", async () => {
+  const fixture = await createFixture({includeCompanion: true})
+  const daemon = await startDaemon(fixture.config)
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+
+    // Simulate the worker having exited (e.g. crashed and exhausted its restart budget).
+    const worker = daemon.activeRelease?.getProcess("worker")
+
+    assert.ok(worker, "worker process should exist")
+    await worker.stop()
+    assert.equal(worker.status().state, "stopped")
+
+    const result = await daemon.restartProcesses({processId: "worker"})
+
+    assert.deepEqual(result.restarted, ["worker"])
+    assert.equal(worker.status().state, "running")
+    assert.ok(worker.status().pid)
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("the restart control command bounces a process over the socket", async () => {
+  const fixture = await createFixture({includeService: true})
+  const daemon = await startDaemon(fixture.config)
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+
+    const before = pidsById(daemon.status())
+    const response = await sendControlCommand({
+      command: {command: "restart", processId: "beacon"},
+      path: fixture.config.control.path
+    })
+
+    assert.deepEqual(response.restarted, ["beacon"])
+    assert.notEqual(pidsById(daemon.status()).beacon, before.beacon)
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
 test("control socket accepts deploy and status commands", async () => {
   const fixture = await createFixture()
   const daemon = await startDaemon(fixture.config)
@@ -285,7 +499,7 @@ test("deploy can ensure the daemon before sending the release command", async ()
 })
 
 /**
- * @param {{includeService?: boolean, includeSingleton?: boolean, webDependsOnService?: boolean}} [options] - Fixture options.
+ * @param {{includeCompanion?: boolean, includeService?: boolean, includeSingleton?: boolean, proxyHost?: string, singletonCwd?: string, webCommand?: string, webDependsOnService?: boolean, webHealthTimeoutMs?: number}} [options] - Fixture options.
  * @returns {Promise<{config: import("../src/config.js").RollbridgeConfig, root: string, serviceLogPath: string, singletonLogPath: string}>} Fixture data.
  */
 async function createFixture(options = {}) {
@@ -308,14 +522,22 @@ async function createFixture(options = {}) {
     })
   }
 
+  if (options.includeCompanion) {
+    processes.push({
+      command: `${JSON.stringify(process.execPath)} -e ${JSON.stringify("setInterval(() => {}, 1000)")}`,
+      id: "worker",
+      policy: "companion"
+    })
+  }
+
   processes.push({
-    command: options.webDependsOnService
+    command: options.webCommand || (options.webDependsOnService
       ? `${JSON.stringify(process.execPath)} ${JSON.stringify(dependentAppPath)}`
-      : `${JSON.stringify(process.execPath)} ${JSON.stringify(dummyAppPath)}`,
+      : `${JSON.stringify(process.execPath)} ${JSON.stringify(dummyAppPath)}`),
     health: {
       intervalMs: 50,
       path: "/ping",
-      timeoutMs: 3000
+      timeoutMs: options.webHealthTimeoutMs || 3000
     },
     id: "web",
     policy: "proxied",
@@ -325,6 +547,7 @@ async function createFixture(options = {}) {
   if (options.includeSingleton) {
     processes.push({
       command: `${JSON.stringify(process.execPath)} ${JSON.stringify(singletonAppPath)}`,
+      ...(options.singletonCwd ? {cwd: options.singletonCwd} : {}),
       env: {
         ROLLBRIDGE_SINGLETON_LOG: singletonLogPath
       },
@@ -344,7 +567,7 @@ async function createFixture(options = {}) {
       forceStopTimeoutMs: 500,
       healthPath: "/ping",
       healthTimeoutMs: 3000,
-      host: "127.0.0.1",
+      host: options.proxyHost || "127.0.0.1",
       port: 0
     }
   })
@@ -415,6 +638,27 @@ function statusRelease(daemon, releaseId) {
   return release
 }
 
+/**
+ * Maps process id to pid across the active release, services, and singletons.
+ * @param {import("../src/daemon.js").DaemonStatus} status - Daemon status payload.
+ * @returns {Record<string, number | undefined>} Process id to current pid.
+ */
+function pidsById(status) {
+  /** @type {Record<string, number | undefined>} */
+  const pids = {}
+
+  for (const release of status.releases) {
+    if (release.state !== "active") continue
+
+    for (const processStatus of release.processes) pids[processStatus.id] = processStatus.pid
+  }
+
+  for (const service of status.services) pids[service.id] = service.process.pid
+  for (const singleton of status.singletons) pids[singleton.id] = singleton.process.pid
+
+  return pids
+}
+
 /**
  * @param {string} logPath - Log path.
  * @returns {Promise<Array<{event: string, pid: number, releaseId: string}>>} Events.

package/scripts/release-patch.js

@@ -1,83 +0,0 @@
-#!/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"])