rollbridge 0.1.2 → 0.1.4

package/test/logs.test.js

@@ -0,0 +1,99 @@
+// @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 from "../src/daemon.js"
+import {normalizeConfig} from "../src/config.js"
+import {formatLogSources, runCli} from "../src/cli.js"
+
+const currentDir = path.dirname(fileURLToPath(import.meta.url))
+const dummyAppPath = path.join(currentDir, "fixtures", "dummy-app.js")
+
+test("formatLogSources renders a section per process with timestamped lines", () => {
+  const output = formatLogSources([
+    {id: "web", logs: [{at: "2026-05-22T00:00:00.000Z", line: "listening", stream: "stdout"}], source: "release v1 (active)"},
+    {id: "beacon", logs: [], source: "service"}
+  ], undefined)
+
+  assert.match(output, /== web \[release v1 \(active\)\] ==/)
+  assert.match(output, /2026-05-22T00:00:00\.000Z \[stdout\] listening/)
+  assert.match(output, /== beacon \[service\] ==/)
+  assert.match(output, /\(no recent output\)/)
+})
+
+test("formatLogSources filters to a single process id", () => {
+  const sources = [
+    {id: "web", logs: [], source: "release v1 (active)"},
+    {id: "beacon", logs: [], source: "service"}
+  ]
+
+  const output = formatLogSources(sources, "web")
+
+  assert.match(output, /== web /)
+  assert.doesNotMatch(output, /beacon/)
+})
+
+test("formatLogSources reports when there are no processes or no match", () => {
+  assert.equal(formatLogSources([], undefined), "No managed processes.")
+  assert.equal(
+    formatLogSources([{id: "web", logs: [], source: "release v1 (active)"}], "missing"),
+    'No process found with id "missing".'
+  )
+})
+
+test("logs CLI prints captured output per managed process", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-logs-"))
+  const socketPath = path.join(root, "rollbridge.sock")
+  const rawConfig = {
+    application: "rollbridge-logs-test",
+    control: {path: socketPath},
+    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: {host: "127.0.0.1", port: 0}
+  }
+
+  // CommonJS config file so the CLI can load it from a temp dir on any Node version.
+  await fs.writeFile(path.join(root, "rollbridge.js"), `module.exports = ${JSON.stringify(rawConfig)}\n`)
+
+  const daemon = new RollbridgeDaemon({config: normalizeConfig(rawConfig), logger: () => {}})
+
+  await daemon.start()
+
+  const originalLog = console.log
+  /** @type {string[]} */
+  const lines = []
+
+  console.log = (/** @type {string[]} */ ...args) => { lines.push(args.map((arg) => String(arg)).join(" ")) }
+
+  try {
+    await daemon.deploy({releaseId: "v1", releasePath: root, revision: "v1"})
+    await runCli(["node", "rollbridge", "logs", "-c", path.join(root, "rollbridge.js")])
+
+    assert.match(lines.join("\n"), /== web \[release v1 \(active\)\] ==/)
+
+    lines.length = 0
+    await runCli(["node", "rollbridge", "logs", "--json", "-c", path.join(root, "rollbridge.js")])
+
+    const parsed = JSON.parse(lines.join("\n"))
+    const web = parsed.find((/** @type {{id: string, logs: import("../src/managed-process.js").ManagedProcessLog[], source: string}} */ entry) => entry.id === "web")
+
+    assert.ok(web, "expected a web entry in the JSON output")
+    assert.match(web.source, /release v1 \(active\)/)
+    assert.ok(Array.isArray(web.logs))
+  } finally {
+    console.log = originalLog
+    await daemon.shutdown()
+    await fs.rm(root, {force: true, recursive: true})
+  }
+})

package/test/managed-process.test.js

@@ -1,9 +1,13 @@
 // @ts-check
 
 import assert from "node:assert/strict"
+import path from "node:path"
 import test from "node:test"
+import {fileURLToPath} from "node:url"
 import ManagedProcess from "../src/managed-process.js"
 
+const crasherPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "fixtures", "crasher.js")
+
 /**
  * Builds a managed process that is never spawned, for exercising output retention directly.
  * @param {number} outputLines - Recent output lines to retain and report.
@@ -23,6 +27,21 @@ function buildProcess(outputLines) {
   })
 }
 
+/**
+ * @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")
+}
+
 test("retains and reports only the configured number of recent output lines", () => {
   const managed = buildProcess(3)
 
@@ -44,3 +63,44 @@ test("keeps every output line when fewer than the retention limit are produced",
 
   assert.deepEqual(logs.map((entry) => entry.line), ["one", "two"])
 })
+
+test("reports zeroed restart and uptime fields before the process starts", () => {
+  const status = buildProcess(50).status()
+
+  assert.equal(status.restarts, 0)
+  assert.equal(status.startedAt, undefined)
+  assert.equal(status.uptimeMs, undefined)
+  assert.equal(status.state, "stopped")
+})
+
+test("counts automatic restarts and reports startedAt and uptime while running", async () => {
+  const managed = new ManagedProcess({
+    command: `${JSON.stringify(process.execPath)} ${JSON.stringify(crasherPath)}`,
+    cwd: undefined,
+    env: {},
+    id: "crasher",
+    logger: () => {},
+    outputLines: 50,
+    restartDelayMs: 20,
+    shouldRestart: () => true,
+    stopTimeoutMs: 500
+  })
+
+  try {
+    await managed.start()
+
+    const initial = managed.status()
+
+    assert.equal(initial.restarts, 0)
+    assert.equal(initial.state, "running")
+    assert.equal(typeof initial.startedAt, "string")
+    assert.ok(typeof initial.uptimeMs === "number" && initial.uptimeMs >= 0)
+
+    // The fixture exits non-zero ~40ms after each start, so it keeps auto-restarting.
+    await waitFor(() => managed.status().restarts >= 2)
+
+    assert.ok(managed.status().restarts >= 2)
+  } finally {
+    await managed.stop()
+  }
+})

package/test/package-metadata.test.js

@@ -0,0 +1,29 @@
+// @ts-check
+
+import assert from "node:assert/strict"
+import fs from "node:fs/promises"
+import path from "node:path"
+import test from "node:test"
+import {fileURLToPath} from "node:url"
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+
+test("package.json declares publish metadata", async () => {
+  const pkg = JSON.parse(await fs.readFile(path.join(repoRoot, "package.json"), "utf8"))
+
+  assert.equal(pkg.name, "rollbridge")
+  assert.equal(pkg.license, "MIT")
+  assert.equal(pkg.homepage, "https://github.com/kaspernj/rollbridge#readme")
+  assert.equal(pkg.bugs.url, "https://github.com/kaspernj/rollbridge/issues")
+  assert.equal(pkg.repository.type, "git")
+  assert.match(pkg.repository.url, /github\.com\/kaspernj\/rollbridge/)
+  assert.ok(typeof pkg.author === "string" && pkg.author.length > 0)
+  assert.ok(Array.isArray(pkg.keywords) && pkg.keywords.length > 0)
+})
+
+test("a LICENSE file matching the declared license exists", async () => {
+  const license = await fs.readFile(path.join(repoRoot, "LICENSE"), "utf8")
+
+  assert.match(license, /MIT License/)
+  assert.match(license, /Copyright \(c\) \d{4} kaspernj/)
+})

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)
@@ -285,7 +336,7 @@ test("deploy can ensure the daemon before sending the release command", async ()
 })
 
 /**
- * @param {{includeService?: boolean, includeSingleton?: boolean, webDependsOnService?: boolean}} [options] - Fixture options.
+ * @param {{includeService?: boolean, includeSingleton?: boolean, proxyHost?: 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 = {}) {
@@ -309,13 +360,13 @@ async function createFixture(options = {}) {
   }
 
   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",
@@ -344,7 +395,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
     }
   })