rollbridge 0.1.13 → 0.1.15

package/src/daemon.js

@@ -18,7 +18,7 @@ const STATE_PERSIST_INTERVAL_MS = 5000
  * @typedef {import("./json.js").JsonValue} JsonValue
  * @typedef {{releaseId?: string, releasePath: string, revision?: string}} DeployArgs
  * @typedef {{id: string, process: import("./managed-process.js").ManagedProcessStatus}} ProcessStatus
- * @typedef {{activeReleaseId: string | null, application: string, control: import("./config.js").ControlConfig, orphans: {id: string, pid: number, releaseId: string | null}[], proxy: {host: string, port: number | undefined, upstreamHost: string}, releases: import("./release-group.js").ReleaseStatus[], services: ProcessStatus[], singletons: ProcessStatus[]}} DaemonStatus
+ * @typedef {{activeReleaseId: string | null, application: string, control: import("./config.js").ControlConfig, daemonRuntime: import("./daemon-runtime.js").DaemonRuntimeIdentity | undefined, orphans: {id: string, pid: number, releaseId: string | null}[], proxy: {host: string, port: number | undefined, upstreamHost: string}, releases: import("./release-group.js").ReleaseStatus[], services: ProcessStatus[], singletons: ProcessStatus[]}} DaemonStatus
  */
 
 export default class RollbridgeDaemon {
@@ -27,10 +27,12 @@ export default class RollbridgeDaemon {
    * @param {import("./config.js").RollbridgeConfig} args.config - Rollbridge config.
    * @param {string} [args.configPath] - Config file path to reload before deploys.
    * @param {(message: string, data?: Record<string, JsonValue>) => void} [args.logger] - Logger.
+   * @param {import("./daemon-runtime.js").DaemonRuntimeIdentity} [args.runtime] - Immutable daemon runtime identity.
    */
-  constructor({config, configPath, logger}) {
+  constructor({config, configPath, logger, runtime}) {
     this.config = config
     this.configPath = configPath
+    this.runtime = runtime
     this.eventLog = new EventLog(EVENT_HISTORY_LIMIT)
 
     const baseLogger = logger || ((message, data = {}) => console.log(JSON.stringify({at: new Date().toISOString(), data, message})))
@@ -64,11 +66,29 @@ export default class RollbridgeDaemon {
     this.proxy.on("error", (error, req, res) => this.onProxyError(error, req, res))
   }
 
-  /** @returns {Promise<void>} Starts proxy and control listeners. */
-  async start() {
+  /**
+   * Starts daemon listeners.
+   * @param {{exposeControl?: boolean}} [options] - Whether to expose the control socket immediately.
+   * @returns {Promise<void>} Resolves when the requested listeners are ready.
+   */
+  async start({exposeControl = true} = {}) {
     await this.reportOrphans()
     await this.startProxy()
+    if (exposeControl) await this.exposeControl()
+  }
+
+  /** @returns {Promise<void>} Exposes control commands and begins periodic state persistence. */
+  async exposeControl() {
+    if (this.stopping) throw new Error("Rollbridge is shutting down")
+
     await this.startControlServer()
+
+    if (this.stopping) {
+      await this.closeServer(this.controlServer)
+      await fs.rm(this.config.control.path, {force: true})
+      throw new Error("Rollbridge is shutting down")
+    }
+
     this.startStatePersistence()
   }
 
@@ -800,6 +820,7 @@ export default class RollbridgeDaemon {
       activeReleaseId: this.activeRelease ? this.activeRelease.releaseId : null,
       application: this.config.application,
       control: {...this.config.control},
+      daemonRuntime: this.runtime ? {...this.runtime} : undefined,
       orphans: [...this.orphans],
       proxy: {
         host: this.config.proxy.host,

package/test/completion.test.js

@@ -44,6 +44,7 @@ test("completion bash prints a sourceable script with commands and option flags"
   assert.match(output, /compgen -W "daemon deploy rollback ensure-daemon status stop restart shutdown validate doctor logs events predeploy-cleanup recover completion"/)
   // A command's own options are completed after the command.
   assert.match(output, /deploy\)\n\s+opts="[^"]*--release-path[^"]*"/)
+  assert.match(output, /ensure-daemon\)\n\s+opts="[^"]*--daemon-runtime-path[^"]*"/)
   assert.match(output, /restart\)\n\s+opts="[^"]*--policy[^"]*"/)
 })
 

package/test/daemon-bootstrap.test.js

@@ -47,7 +47,7 @@ test("daemon bootstrap activates the exact release through the foreground daemon
   const child = spawnDaemon(fixture, {releaseId: "release-42", revision: "abc123"})
 
   try {
-    await waitForLog(child, "traffic switched")
+    await waitForLog(child, "control socket listening")
     const status = await sendControlCommand({command: {command: "status"}, path: fixture.socketPath})
     const activeRelease = assertRelease(status, "release-42")
 
@@ -64,6 +64,33 @@ test("daemon bootstrap activates the exact release through the foreground daemon
   }
 })
 
+test("daemon bootstrap does not expose control deploys until activation completes", async () => {
+  const fixture = await createFixture({healthGate: true, healthTimeoutMs: 60000})
+  const started = waitForFile(fixture.startedPath)
+  const child = spawnDaemon(fixture, {releaseId: "bootstrap-release", revision: "bootstrap123"})
+
+  try {
+    await started
+    await assert.rejects(() => fs.stat(fixture.socketPath), {code: "ENOENT"})
+
+    await fs.writeFile(fixture.healthGatePath, "ready\n")
+    await waitForLog(child, "control socket listening")
+
+    const status = await sendControlCommand({command: {command: "status"}, path: fixture.socketPath})
+
+    assert.equal(status.activeReleaseId, "bootstrap-release")
+    assert.ok(Array.isArray(status.releases))
+    assert.equal(status.releases.length, 1)
+    assertRelease(status, "bootstrap-release")
+
+    child.kill("SIGTERM")
+    assert.equal((await once(child, "exit"))[0], 0)
+  } finally {
+    if (child.exitCode === null) child.kill("SIGKILL")
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
 test("plain daemon startup remains listener-only with no active release", async () => {
   const fixture = await createFixture()
   const child = spawn(process.execPath, [binPath, "daemon", "--config", fixture.configPath], {stdio: ["pipe", "pipe", "pipe"]})
@@ -182,7 +209,7 @@ test("daemon bootstrap reports but does not kill a live process from statePath",
   const child = spawnDaemon(fixture, {releaseId: "recovered", revision: "def456"})
 
   try {
-    await waitForLog(child, "traffic switched")
+    await waitForLog(child, "control socket listening")
     const status = await sendControlCommand({command: {command: "status"}, path: fixture.socketPath})
 
     assert.ok(leftover.pid !== undefined && isProcessAlive(leftover.pid))
@@ -228,10 +255,10 @@ test("failed daemon bootstrap preserves prior live process records in statePath"
 })
 
 /**
- * @param {{healthPath?: string, healthTimeoutMs?: number, multiProcessSignal?: boolean, persistState?: boolean}} [options] - Fixture options.
- * @returns {Promise<{configPath: string, gatePath: string, lifecyclePath: string, root: string, socketPath: string, startedPath: string, statePath: string, stoppedPath: string}>} Fixture paths.
+ * @param {{healthGate?: boolean, healthPath?: string, healthTimeoutMs?: number, multiProcessSignal?: boolean, persistState?: boolean}} [options] - Fixture options.
+ * @returns {Promise<{configPath: string, gatePath: string, healthGatePath: string, lifecyclePath: string, root: string, socketPath: string, startedPath: string, statePath: string, stoppedPath: string}>} Fixture paths.
  */
-async function createFixture({healthPath = "/ping", healthTimeoutMs = 1000, multiProcessSignal = false, persistState = false} = {}) {
+async function createFixture({healthGate = false, healthPath = "/ping", healthTimeoutMs = 1000, multiProcessSignal = false, persistState = false} = {}) {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-bootstrap-"))
   const socketPath = path.join(root, "control.sock")
   const statePath = path.join(root, "state.json")
@@ -239,9 +266,15 @@ async function createFixture({healthPath = "/ping", healthTimeoutMs = 1000, mult
   const stoppedPath = path.join(root, "stopped.pid")
   const lifecyclePath = path.join(root, "lifecycle.jsonl")
   const gatePath = path.join(root, "continue.fifo")
+  const healthGatePath = path.join(root, "health-ready")
   const configPath = path.join(root, "rollbridge.js")
   const command = `${JSON.stringify(process.execPath)} ${JSON.stringify(dummyAppPath)}`
   const lifecycleEnv = {ROLLBRIDGE_TEST_LIFECYCLE_PATH: lifecyclePath}
+  const webEnv = {
+    ROLLBRIDGE_TEST_STARTED_PATH: startedPath,
+    ROLLBRIDGE_TEST_STOPPED_PATH: stoppedPath,
+    ...(healthGate ? {ROLLBRIDGE_TEST_HEALTH_GATE_PATH: healthGatePath} : {})
+  }
   const config = {
     application: "bootstrap-test",
     control: {path: socketPath},
@@ -249,7 +282,7 @@ async function createFixture({healthPath = "/ping", healthTimeoutMs = 1000, mult
       {command: `trap '' TERM; printf '%s\\n' '{"event":"shutdown"}' >> ${JSON.stringify(lifecyclePath)}; kill -TERM "$ROLLBRIDGE_TEST_DAEMON_PID"; printf '{"event":"started","pid":%s,"processId":"database","replicaIndex":"0"}\\n' "$$" >> ${JSON.stringify(lifecyclePath)}; read ignored < ${JSON.stringify(gatePath)}`, env: lifecycleEnv, id: "database", policy: "service"},
       {command: `exec ${command}`, env: lifecycleEnv, id: "worker", policy: "companion", replicas: 2},
       {command: `exec ${command}`, env: lifecycleEnv, health: {path: healthPath, timeoutMs: healthTimeoutMs}, id: "web", policy: "proxied", port: {from: 0, to: 0}}
-    ] : [{command, env: {ROLLBRIDGE_TEST_STARTED_PATH: startedPath, ROLLBRIDGE_TEST_STOPPED_PATH: stoppedPath}, health: {path: healthPath, timeoutMs: healthTimeoutMs}, id: "web", policy: "proxied", port: {from: 0, to: 0}}],
+    ] : [{command, env: webEnv, health: {path: healthPath, timeoutMs: healthTimeoutMs}, id: "web", policy: "proxied", port: {from: 0, to: 0}}],
     proxy: {host: "127.0.0.1", port: 0},
     ...(persistState ? {statePath} : {})
   }
@@ -264,7 +297,7 @@ async function createFixture({healthPath = "/ping", healthTimeoutMs = 1000, mult
   }
 
   await fs.writeFile(configPath, `${setup}module.exports = ${JSON.stringify(config, null, 2)}\n`)
-  return {configPath, gatePath, lifecyclePath, root, socketPath, startedPath, statePath, stoppedPath}
+  return {configPath, gatePath, healthGatePath, lifecyclePath, root, socketPath, startedPath, statePath, stoppedPath}
 }
 
 /**

package/test/daemon-runtime.test.js

@@ -0,0 +1,90 @@
+// @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 {prepareDaemonRuntime} from "../src/daemon-runtime.js"
+
+test("concurrent runtime preparation converges on one validated content-addressed snapshot", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-runtime-concurrent-"))
+
+  try {
+    const identities = await Promise.all([
+      prepareDaemonRuntime(root),
+      prepareDaemonRuntime(root),
+      prepareDaemonRuntime(root)
+    ])
+
+    assert.deepEqual(identities, [identities[0], identities[0], identities[0]])
+    assert.match(identities[0].digest, /^[a-f0-9]{64}$/)
+    assert.equal(path.dirname(identities[0].path), root)
+    assert.equal(JSON.parse(await fs.readFile(path.join(identities[0].path, "runtime.json"), "utf8")).digest, identities[0].digest)
+
+    const entries = (await fs.readdir(root)).filter((entry) => entry.startsWith(".prepare-"))
+    assert.deepEqual(entries, [])
+  } finally {
+    await fs.rm(root, {force: true, recursive: true})
+  }
+})
+
+test("preparation fails closed when an existing content-addressed snapshot is corrupt", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-runtime-corrupt-"))
+
+  try {
+    const identity = await prepareDaemonRuntime(root)
+
+    await fs.writeFile(path.join(identity.path, "src", "daemon.js"), "corrupt\n")
+    await assert.rejects(() => prepareDaemonRuntime(root), /runtime validation failed/)
+  } finally {
+    await fs.rm(root, {force: true, recursive: true})
+  }
+})
+
+test("runtime preparation rejects a symlinked or shared-writable parent", async (t) => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-runtime-permissions-"))
+  const target = path.join(root, "target")
+  const symlink = path.join(root, "symlink")
+  const shared = path.join(root, "shared")
+
+  try {
+    await fs.mkdir(target)
+    await fs.symlink(target, symlink, "dir")
+    await assert.rejects(() => prepareDaemonRuntime(symlink), /must be a real directory/)
+
+    if (process.platform === "win32") {
+      t.skip("POSIX directory permissions are not available on Windows")
+      return
+    }
+
+    await fs.mkdir(shared, {mode: 0o777})
+    await fs.chmod(shared, 0o777)
+    await assert.rejects(() => prepareDaemonRuntime(shared), /must not be writable by group or other users/)
+  } finally {
+    await fs.rm(root, {force: true, recursive: true})
+  }
+})
+
+test("runtime preparation rejects a private leaf beneath a replaceable ancestor", async (t) => {
+  if (process.platform === "win32") {
+    t.skip("POSIX directory permissions are not available on Windows")
+    return
+  }
+
+  const unsafeAncestor = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-runtime-unsafe-ancestor-"))
+  const privateLeaf = path.join(unsafeAncestor, "private-runtime")
+
+  try {
+    await fs.chmod(unsafeAncestor, 0o777)
+    await fs.mkdir(privateLeaf, {mode: 0o700})
+
+    await assert.rejects(
+      () => prepareDaemonRuntime(privateLeaf),
+      /ancestor must be sticky or not writable by group or other users/
+    )
+  } finally {
+    await fs.chmod(unsafeAncestor, 0o700)
+    await fs.rm(unsafeAncestor, {force: true, recursive: true})
+  }
+})

package/test/fixtures/dummy-app.js

@@ -15,7 +15,7 @@ if (process.env.ROLLBRIDGE_TEST_STARTED_PATH) {
 
 const server = http.createServer((request, response) => {
   if (request.url === "/ping") {
-    if (healthFails) {
+    if (healthFails || (process.env.ROLLBRIDGE_TEST_HEALTH_GATE_PATH && !fs.existsSync(process.env.ROLLBRIDGE_TEST_HEALTH_GATE_PATH))) {
       response.writeHead(500, {"Content-Type": "application/json"})
       response.end(JSON.stringify({message: "bad release"}))
       return

package/test/package-metadata.test.js

@@ -1,12 +1,16 @@
 // @ts-check
 
 import assert from "node:assert/strict"
+import {execFile} from "node:child_process"
 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 {promisify} from "node:util"
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const execFileAsync = promisify(execFile)
 
 test("package.json declares publish metadata", async () => {
   const pkg = JSON.parse(await fs.readFile(path.join(repoRoot, "package.json"), "utf8"))
@@ -27,3 +31,38 @@ test("a LICENSE file matching the declared license exists", async () => {
   assert.match(license, /MIT License/)
   assert.match(license, /Copyright \(c\) \d{4} kaspernj/)
 })
+
+test("package manifest excludes unexpected operational and coverage files", async (t) => {
+  const fixtureRoot = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-pack-"))
+  t.after(() => fs.rm(fixtureRoot, {force: true, recursive: true}))
+
+  await fs.cp(repoRoot, fixtureRoot, {
+    filter: (source) => {
+      const relative = path.relative(repoRoot, source)
+      return relative !== ".git" && relative !== "node_modules" && relative !== "tmp"
+    },
+    recursive: true,
+  })
+
+  const unexpectedTmpPath = path.join(fixtureRoot, "tmp", "worker-control", "unexpected-transcript.jsonl")
+  const unexpectedCoveragePath = path.join(fixtureRoot, "coverage", "unexpected.txt")
+  await Promise.all([
+    fs.mkdir(path.dirname(unexpectedTmpPath), {recursive: true}),
+    fs.mkdir(path.dirname(unexpectedCoveragePath), {recursive: true}),
+  ])
+  await Promise.all([
+    fs.writeFile(unexpectedTmpPath, '{"operational":"state"}\n'),
+    fs.writeFile(unexpectedCoveragePath, "unexpected coverage output\n"),
+  ])
+
+  const {stdout} = await execFileAsync("npm", ["pack", "--dry-run", "--json"], {cwd: fixtureRoot})
+  /** @type {Array<{path: string}>} */
+  const packageFiles = JSON.parse(stdout)[0].files
+  const packagePaths = packageFiles.map((file) => file.path)
+
+  for (const requiredPath of ["LICENSE", "README.md", "bin/rollbridge", "package.json", "src/cli.js", "src/daemon-runtime.js"]) {
+    assert.ok(packagePaths.includes(requiredPath), `expected package to include ${requiredPath}`)
+  }
+  assert.ok(!packagePaths.some((packagePath) => packagePath === "tmp" || packagePath.startsWith("tmp/")))
+  assert.ok(!packagePaths.some((packagePath) => packagePath === "coverage" || packagePath.startsWith("coverage/")))
+})