rollbridge 0.1.11 → 0.1.13

package/test/daemon-bootstrap.test.js

@@ -0,0 +1,363 @@
+// @ts-check
+
+import assert from "node:assert/strict"
+import {spawn} from "node:child_process"
+import {once} from "node:events"
+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 {sendControlCommand} from "../src/control-client.js"
+import {isProcessAlive, liveProcesses, readState, writeState} from "../src/state-store.js"
+
+const currentDir = path.dirname(fileURLToPath(import.meta.url))
+const binPath = path.join(currentDir, "..", "bin", "rollbridge")
+const dummyAppPath = path.join(currentDir, "fixtures", "dummy-app.js")
+
+test("daemon bootstrap requires complete, safe, absolute inputs before binding listeners", async (t) => {
+  const cases = [
+    {args: ["--config", "CONFIG", "--release-path", "RELEASE", "--release-id", "v1"], message: /must be provided together/},
+    {args: ["--config", "relative/config.js", "--release-path", "RELEASE", "--release-id", "v1", "--revision", "abc123"], message: /--config must be an absolute path/},
+    {args: ["--config", "CONFIG", "--release-path", "relative/release", "--release-id", "v1", "--revision", "abc123"], message: /--release-path must be an absolute path/},
+    {args: ["--config", "CONFIG", "--release-path", "RELEASE", "--release-id", "unsafe id", "--revision", "abc123"], message: /--release-id/},
+    {args: ["--config", "CONFIG", "--release-path", "RELEASE", "--release-id", "v1", "--revision", "unsafe revision"], message: /--revision/}
+  ]
+
+  for (const testCase of cases) {
+    await t.test(testCase.message.source, async () => {
+      const fixture = await createFixture()
+      const args = testCase.args.map((arg) => arg === "CONFIG" ? fixture.configPath : arg === "RELEASE" ? fixture.root : arg)
+
+      try {
+        const result = await runDaemon(args)
+
+        assert.notEqual(result.code, 0)
+        assert.match(result.stderr, testCase.message)
+        await assert.rejects(() => fs.stat(fixture.socketPath), {code: "ENOENT"})
+      } finally {
+        await fs.rm(fixture.root, {force: true, recursive: true})
+      }
+    })
+  }
+})
+
+test("daemon bootstrap activates the exact release through the foreground daemon", async () => {
+  const fixture = await createFixture()
+  const child = spawnDaemon(fixture, {releaseId: "release-42", revision: "abc123"})
+
+  try {
+    await waitForLog(child, "traffic switched")
+    const status = await sendControlCommand({command: {command: "status"}, path: fixture.socketPath})
+    const activeRelease = assertRelease(status, "release-42")
+
+    assert.equal(activeRelease.releasePath, fixture.root)
+    assert.equal(activeRelease.revision, "abc123")
+    assert.ok(status.proxy && typeof status.proxy === "object" && !Array.isArray(status.proxy) && typeof status.proxy.port === "number")
+    assert.equal((await fetch(`http://127.0.0.1:${status.proxy.port}/release`).then((response) => response.text())).trim(), "release-42")
+
+    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"]})
+
+  try {
+    await waitForLog(child, "control socket listening")
+    const status = await sendControlCommand({command: {command: "status"}, path: fixture.socketPath})
+
+    assert.equal(status.activeReleaseId, null)
+    assert.deepEqual(status.releases, [])
+
+    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("SIGTERM during bootstrap activation follows the daemon shutdown path", async () => {
+  const fixture = await createFixture({healthPath: "/never-ready", healthTimeoutMs: 60000})
+  const started = waitForFile(fixture.startedPath)
+  const child = spawnDaemon(fixture, {releaseId: "slow-release", revision: "slow123"})
+
+  try {
+    const managedPid = Number(await started)
+    child.kill("SIGTERM")
+
+    const [code, signal] = await once(child, "exit")
+
+    assert.equal(code, 0)
+    assert.equal(signal, null)
+    assert.equal(await fs.readFile(fixture.stoppedPath, "utf8"), String(managedPid))
+    await assert.rejects(() => fs.stat(fixture.socketPath), {code: "ENOENT"})
+  } finally {
+    if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL")
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("SIGTERM during multi-process bootstrap owns every process started after shutdown begins", async () => {
+  const fixture = await createFixture({multiProcessSignal: true})
+  const shutdownStarted = waitForLifecycleEvent(fixture.lifecyclePath, (event) => event.event === "shutdown")
+  const child = spawnDaemon(fixture, {releaseId: "multi-release", revision: "multi123"})
+  let output = ""
+
+  child.stdout.setEncoding("utf8").on("data", (chunk) => { output += chunk })
+
+  try {
+    await shutdownStarted
+    await fs.writeFile(fixture.gatePath, "continue\n")
+    const [code, signal] = await once(child, "exit")
+    const events = (await fs.readFile(fixture.lifecyclePath, "utf8")).trim().split("\n").map((line) => JSON.parse(line))
+    const shutdownIndex = events.findIndex((event) => event.event === "shutdown")
+    const startedAfterShutdown = events.slice(shutdownIndex + 1).filter((event) => event.event === "started")
+    const records = output.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line))
+    const recordedPids = new Set(records.filter((record) => record.message === "process started").map((record) => record.data?.pid))
+
+    assert.equal(code, 0)
+    assert.equal(signal, null)
+    assert.notEqual(shutdownIndex, -1)
+    assert.ok(startedAfterShutdown.length > 0, `fixture must start a later bootstrap process after triggering shutdown: ${JSON.stringify(events)}`)
+    assert.deepEqual(startedAfterShutdown.filter((event) => !recordedPids.has(event.pid)), [])
+    for (const event of startedAfterShutdown) assert.equal(isProcessAlive(event.pid), false, `expected process ${event.pid} to be stopped before daemon exit`)
+  } finally {
+    if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL")
+
+    try {
+      const events = (await fs.readFile(fixture.lifecyclePath, "utf8")).trim().split("\n").filter(Boolean).map((line) => JSON.parse(line))
+
+      for (const event of events) {
+        if (event.event === "started" && isProcessAlive(event.pid)) process.kill(-event.pid, "SIGKILL")
+      }
+    } catch {
+      // The fixture may exit before creating its lifecycle log.
+    }
+
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("failed daemon bootstrap reports a structured failure, cleans its processes, and exits non-zero", async () => {
+  const fixture = await createFixture({healthPath: "/never-ready", healthTimeoutMs: 100})
+
+  try {
+    const result = await runDaemon([
+      "--config", fixture.configPath,
+      "--release-path", fixture.root,
+      "--release-id", "bad-release",
+      "--revision", "bad123"
+    ])
+    const records = result.output.split("\n").filter(Boolean).map((line) => JSON.parse(line))
+    const failure = records.find((record) => record.message === "bootstrap activation failed")
+
+    assert.notEqual(result.code, 0)
+    assert.deepEqual(failure?.data, {releaseId: "bad-release", status: "error"})
+    assert.ok(records.some((record) => record.message === "release startup process status" && record.data?.phase === "after cleanup" && record.data?.state === "stopped"))
+    await assert.rejects(() => fs.stat(fixture.socketPath), {code: "ENOENT"})
+  } finally {
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("daemon bootstrap reports but does not kill a live process from statePath", async () => {
+  const fixture = await createFixture({persistState: true})
+  const leftover = spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], {stdio: "ignore"})
+
+  await once(leftover, "spawn")
+  await writeState(fixture.statePath, {
+    activeReleaseId: "previous",
+    releases: [{processes: [{id: "worker", pid: leftover.pid}], releaseId: "previous"}],
+    services: [],
+    singletons: []
+  })
+
+  const child = spawnDaemon(fixture, {releaseId: "recovered", revision: "def456"})
+
+  try {
+    await waitForLog(child, "traffic switched")
+    const status = await sendControlCommand({command: {command: "status"}, path: fixture.socketPath})
+
+    assert.ok(leftover.pid !== undefined && isProcessAlive(leftover.pid))
+    assert.deepEqual(status.orphans, [{id: "worker", pid: leftover.pid, releaseId: "previous"}])
+
+    child.kill("SIGTERM")
+    await once(child, "exit")
+
+    assert.deepEqual(liveProcesses(await readState(fixture.statePath)), [{id: "worker", pid: leftover.pid, releaseId: "previous"}])
+  } finally {
+    if (child.exitCode === null) child.kill("SIGKILL")
+    leftover.kill("SIGKILL")
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("failed daemon bootstrap preserves prior live process records in statePath", async () => {
+  const fixture = await createFixture({healthPath: "/never-ready", healthTimeoutMs: 100, persistState: true})
+  const leftover = spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], {stdio: "ignore"})
+
+  await once(leftover, "spawn")
+  await writeState(fixture.statePath, {
+    activeReleaseId: "previous",
+    releases: [{processes: [{id: "worker", pid: leftover.pid}], releaseId: "previous"}],
+    services: [],
+    singletons: []
+  })
+
+  try {
+    const result = await runDaemon([
+      "--config", fixture.configPath,
+      "--release-path", fixture.root,
+      "--release-id", "bad-release",
+      "--revision", "bad123"
+    ])
+
+    assert.notEqual(result.code, 0)
+    assert.deepEqual(liveProcesses(await readState(fixture.statePath)), [{id: "worker", pid: leftover.pid, releaseId: "previous"}])
+  } finally {
+    leftover.kill("SIGKILL")
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+/**
+ * @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.
+ */
+async function createFixture({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")
+  const startedPath = path.join(root, "started.pid")
+  const stoppedPath = path.join(root, "stopped.pid")
+  const lifecyclePath = path.join(root, "lifecycle.jsonl")
+  const gatePath = path.join(root, "continue.fifo")
+  const configPath = path.join(root, "rollbridge.js")
+  const command = `${JSON.stringify(process.execPath)} ${JSON.stringify(dummyAppPath)}`
+  const lifecycleEnv = {ROLLBRIDGE_TEST_LIFECYCLE_PATH: lifecyclePath}
+  const config = {
+    application: "bootstrap-test",
+    control: {path: socketPath},
+    processes: multiProcessSignal ? [
+      {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}}],
+    proxy: {host: "127.0.0.1", port: 0},
+    ...(persistState ? {statePath} : {})
+  }
+
+  const setup = multiProcessSignal ? "process.env.ROLLBRIDGE_TEST_DAEMON_PID = String(process.pid)\n" : ""
+
+  if (multiProcessSignal) {
+    const fifo = spawn("mkfifo", [gatePath])
+    const [code] = await once(fifo, "exit")
+
+    assert.equal(code, 0)
+  }
+
+  await fs.writeFile(configPath, `${setup}module.exports = ${JSON.stringify(config, null, 2)}\n`)
+  return {configPath, gatePath, lifecyclePath, root, socketPath, startedPath, statePath, stoppedPath}
+}
+
+/**
+ * @param {string} filePath - JSON-lines event path.
+ * @param {(event: Record<string, import("../src/json.js").JsonValue>) => boolean} matches - Event predicate.
+ * @returns {Promise<Record<string, import("../src/json.js").JsonValue>>} First matching event.
+ */
+async function waitForLifecycleEvent(filePath, matches) {
+  const watcher = fs.watch(path.dirname(filePath))
+
+  try {
+    for await (const event of watcher) {
+      if (event.filename !== path.basename(filePath)) continue
+
+      const records = (await fs.readFile(filePath, "utf8")).trim().split("\n").filter(Boolean).map((line) => JSON.parse(line))
+      const match = records.find(matches)
+
+      if (match) return match
+    }
+  } finally {
+    await watcher.return?.()
+  }
+
+  throw new Error(`File watcher ended before a matching event was written to ${filePath}`)
+}
+
+/**
+ * @param {string} filePath - File whose creation is the synchronization point.
+ * @returns {Promise<string>} File contents once created.
+ */
+async function waitForFile(filePath) {
+  const watcher = fs.watch(path.dirname(filePath))
+
+  try {
+    for await (const event of watcher) {
+      if (event.filename === path.basename(filePath)) return await fs.readFile(filePath, "utf8")
+    }
+  } finally {
+    await watcher.return?.()
+  }
+
+  throw new Error(`File watcher ended before ${filePath} was created`)
+}
+
+/**
+ * @param {{configPath: string, root: string}} fixture - Fixture paths.
+ * @param {{releaseId: string, revision: string}} release - Bootstrap metadata.
+ * @returns {import("node:child_process").ChildProcessWithoutNullStreams} Spawned daemon.
+ */
+function spawnDaemon(fixture, release) {
+  return spawn(process.execPath, [binPath, "daemon", "--config", fixture.configPath, "--release-path", fixture.root, "--release-id", release.releaseId, "--revision", release.revision], {stdio: ["pipe", "pipe", "pipe"]})
+}
+
+/**
+ * @param {string[]} args - Daemon arguments.
+ * @returns {Promise<{code: number | null, output: string, stderr: string}>} Completed process result.
+ */
+async function runDaemon(args) {
+  const child = spawn(process.execPath, [binPath, "daemon", ...args], {stdio: ["ignore", "pipe", "pipe"]})
+  let output = ""
+  let stderr = ""
+
+  child.stdout.setEncoding("utf8").on("data", (chunk) => { output += chunk })
+  child.stderr.setEncoding("utf8").on("data", (chunk) => { stderr += chunk })
+  const [code] = await once(child, "exit")
+
+  return {code, output, stderr}
+}
+
+/**
+ * @param {import("node:child_process").ChildProcessWithoutNullStreams} child - Spawned daemon.
+ * @param {string} message - Structured log message to await.
+ * @returns {Promise<void>} Resolves after the message is observed.
+ */
+async function waitForLog(child, message) {
+  child.stdout.setEncoding("utf8")
+
+  for await (const chunk of child.stdout) {
+    if (String(chunk).includes(`"message":"${message}"`)) return
+  }
+
+  throw new Error(`Daemon exited before logging ${message}`)
+}
+
+/**
+ * @param {Record<string, import("../src/json.js").JsonValue>} status - Daemon status.
+ * @param {string} releaseId - Expected release id.
+ * @returns {Record<string, import("../src/json.js").JsonValue>} Matching release status.
+ */
+function assertRelease(status, releaseId) {
+  assert.ok(Array.isArray(status.releases))
+  const release = status.releases.find((candidate) => candidate && typeof candidate === "object" && "releaseId" in candidate && candidate.releaseId === releaseId)
+
+  assert.ok(release && typeof release === "object" && !Array.isArray(release))
+  return release
+}

package/test/fixtures/dummy-app.js

@@ -1,6 +1,7 @@
 // @ts-check
 
 import crypto from "node:crypto"
+import fs from "node:fs"
 import http from "node:http"
 
 const port = Number(process.env.ROLLBRIDGE_PORT)
@@ -8,6 +9,10 @@ const releaseId = process.env.ROLLBRIDGE_RELEASE_ID || "unknown"
 const healthFails = releaseId.includes("bad")
 const sockets = new Set()
 
+if (process.env.ROLLBRIDGE_TEST_STARTED_PATH) {
+  fs.writeFileSync(process.env.ROLLBRIDGE_TEST_STARTED_PATH, String(process.pid))
+}
+
 const server = http.createServer((request, response) => {
   if (request.url === "/ping") {
     if (healthFails) {
@@ -59,6 +64,14 @@ server.on("upgrade", (request, socket) => {
 })
 
 process.on("SIGTERM", () => {
+  if (process.env.ROLLBRIDGE_TEST_LIFECYCLE_PATH) {
+    fs.appendFileSync(process.env.ROLLBRIDGE_TEST_LIFECYCLE_PATH, `${JSON.stringify({event: "stopped", pid: process.pid, processId: process.env.ROLLBRIDGE_PROCESS_ID, replicaIndex: process.env.ROLLBRIDGE_REPLICA_INDEX})}\n`)
+  }
+
+  if (process.env.ROLLBRIDGE_TEST_STOPPED_PATH) {
+    fs.writeFileSync(process.env.ROLLBRIDGE_TEST_STOPPED_PATH, String(process.pid))
+  }
+
   server.close(() => process.exit(0))
 
   if (sockets.size === 0) {
@@ -66,4 +79,14 @@ process.on("SIGTERM", () => {
   }
 })
 
-server.listen(port, "127.0.0.1")
+const recordStarted = () => {
+  if (process.env.ROLLBRIDGE_TEST_LIFECYCLE_PATH) {
+    fs.appendFileSync(process.env.ROLLBRIDGE_TEST_LIFECYCLE_PATH, `${JSON.stringify({event: "started", pid: process.pid, processId: process.env.ROLLBRIDGE_PROCESS_ID, replicaIndex: process.env.ROLLBRIDGE_REPLICA_INDEX})}\n`)
+  }
+}
+
+if (process.env.ROLLBRIDGE_PORT) {
+  server.listen(port, "127.0.0.1", recordStarted)
+} else {
+  recordStarted()
+}

package/test/rollbridge.test.js

@@ -102,6 +102,96 @@ test("failed health check leaves the previous release active", async () => {
   }
 })
 
+test("deploy reloads process config and retires the previous worker with the refreshed timeout", async () => {
+  const fixture = await createFixture({nonBlockingDrainWorker: true, workerStopDelayMs: 10000})
+  const initialConfig = normalizeConfig({
+    ...fixture.config,
+    processes: fixture.config.processes.map((processConfig) => processConfig.id === "worker"
+      ? {...processConfig, gracefulStopMs: "indefinite"}
+      : processConfig)
+  })
+  const configPath = await writeConfigFile(initialConfig, fixture.root)
+  const daemon = new RollbridgeDaemon({config: initialConfig, configPath, logger: () => {}})
+
+  try {
+    await daemon.start()
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+
+    const refreshedConfig = normalizeConfig({
+      ...initialConfig,
+      processes: initialConfig.processes.map((processConfig) => processConfig.id === "worker"
+        ? {...processConfig, gracefulStopMs: 50}
+        : processConfig)
+    })
+
+    await writeConfigFile(refreshedConfig, fixture.root)
+    await daemon.deploy({releaseId: "v2", releasePath: fixture.root, revision: "v2"})
+    await waitFor(() => statusRelease(daemon, "v1").processes.find((processStatus) => processStatus.id === "worker")?.state === "stopped", 1000)
+
+    assert.equal(daemon.config.processes.find((processConfig) => processConfig.id === "worker")?.gracefulStopMs, 50)
+    assert.equal(await fetchText(daemon, "/release"), "v2")
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("deploy rejects a reloaded config that changes the running proxy", async () => {
+  const fixture = await createFixture()
+  const configPath = await writeConfigFile(fixture.config, fixture.root)
+  const daemon = new RollbridgeDaemon({config: fixture.config, configPath, logger: () => {}})
+
+  try {
+    await daemon.start()
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+    await writeConfigFile(normalizeConfig({
+      ...fixture.config,
+      proxy: {...fixture.config.proxy, host: "0.0.0.0"}
+    }), fixture.root)
+
+    await assert.rejects(
+      () => daemon.deploy({releaseId: "v2", releasePath: fixture.root, revision: "v2"}),
+      /proxy\.host.*restart the Rollbridge daemon/
+    )
+    assert.equal(daemon.status().activeReleaseId, "v1")
+    assert.equal(await fetchText(daemon, "/release"), "v1")
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
+test("a failed deploy does not adopt reloaded process config", async () => {
+  const fixture = await createFixture()
+  const configPath = await writeConfigFile(fixture.config, fixture.root)
+  const daemon = new RollbridgeDaemon({config: fixture.config, configPath, logger: () => {}})
+
+  try {
+    await daemon.start()
+    await daemon.deploy({releaseId: "v1", releasePath: fixture.root, revision: "v1"})
+
+    const failingConfig = normalizeConfig({
+      ...fixture.config,
+      processes: fixture.config.processes.map((processConfig) => processConfig.id === "web"
+        ? {...processConfig, health: {...processConfig.health, path: "/not-ready", timeoutMs: 100}}
+        : processConfig)
+    })
+
+    await writeConfigFile(failingConfig, fixture.root)
+    await assert.rejects(
+      () => daemon.deploy({releaseId: "v2", releasePath: fixture.root, revision: "v2"}),
+      /Health check failed/
+    )
+
+    assert.equal(daemon.config.processes.find((processConfig) => processConfig.id === "web")?.health?.path, "/ping")
+    assert.equal(daemon.status().activeReleaseId, "v1")
+    assert.equal(await fetchText(daemon, "/release"), "v1")
+  } finally {
+    await daemon.shutdown()
+    await fs.rm(fixture.root, {force: true, recursive: true})
+  }
+})
+
 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)
@@ -1276,10 +1366,9 @@ async function processEvents(logPath) {
  * @returns {Promise<string>} Written config path.
  */
 async function writeConfigFile(config, root) {
-  const configPath = path.join(root, "rollbridge.js")
+  const configPath = path.join(root, "rollbridge.mjs")
 
-  // CommonJS so the module loads from a temp dir (no package.json) on any supported Node version.
-  await fs.writeFile(configPath, `module.exports = ${JSON.stringify(config, null, 2)}\n`)
+  await fs.writeFile(configPath, `export default ${JSON.stringify(config, null, 2)}\n`)
 
   return configPath
 }

package/tmp/worker-control/rollbridge-bootstrap/activity-3.jsonl

@@ -0,0 +1,28 @@
+{"type":"controller-started","pid":23,"at":1786618711548}
+{"type":"provider-started","provider":"codex","pid":34,"at":1786618711553}
+{"type":"session-available","provider":"codex","sessionId":"019ffac6-1176-7023-8f14-82bae745817f","at":1786618712506}
+{"type":"activity","provider":"codex","kind":"lifecycle","at":1786618712506}
+{"type":"activity","provider":"codex","kind":"delta","at":1786618717893}
+{"type":"activity","provider":"codex","kind":"tool","at":1786618723182}
+{"type":"activity","provider":"codex","kind":"tool","at":1786618730240}
+{"type":"activity","provider":"codex","kind":"tool","at":1786618740515}
+{"type":"activity","provider":"codex","kind":"tool","at":1786618746269}
+{"type":"activity","provider":"codex","kind":"delta","at":1786618770657}
+{"type":"activity","provider":"codex","kind":"tool","at":1786618811295}
+{"type":"activity","provider":"codex","kind":"tool","at":1786618816349}
+{"type":"activity","provider":"codex","kind":"tool","at":1786618859240}
+{"type":"activity","provider":"codex","kind":"tool","at":1786618872926}
+{"type":"activity","provider":"codex","kind":"delta","at":1786618889245}
+{"type":"activity","provider":"codex","kind":"tool","at":1786618908545}
+{"type":"activity","provider":"codex","kind":"tool","at":1786618913878}
+{"type":"activity","provider":"codex","kind":"delta","at":1786618934507}
+{"type":"activity","provider":"codex","kind":"tool","at":1786618940248}
+{"type":"activity","provider":"codex","kind":"tool","at":1786618945887}
+{"type":"activity","provider":"codex","kind":"tool","at":1786618960106}
+{"type":"activity","provider":"codex","kind":"tool","at":1786618969417}
+{"type":"activity","provider":"codex","kind":"delta","at":1786618976649}
+{"type":"activity","provider":"codex","kind":"tool","at":1786618996642}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619006003}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619014397}
+{"type":"activity","provider":"codex","kind":"delta","at":1786619021770}
+{"type":"terminal","provider":"codex","state":"completed","exitCode":0,"at":1786619026150}

package/tmp/worker-control/rollbridge-bootstrap/current-head-review-activity.jsonl

@@ -0,0 +1,13 @@
+{"type":"controller-started","pid":23,"at":1786619870796}
+{"type":"provider-started","provider":"codex","pid":34,"at":1786619870799}
+{"type":"session-available","provider":"codex","sessionId":"019ffad7-bed8-7861-911f-83cd5de11373","at":1786619871013}
+{"type":"activity","provider":"codex","kind":"lifecycle","at":1786619871014}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619877574}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619886232}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619894201}
+{"type":"activity","provider":"codex","kind":"delta","at":1786619899492}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619905754}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619921741}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619931957}
+{"type":"activity","provider":"codex","kind":"delta","at":1786619937323}
+{"type":"terminal","provider":"codex","state":"completed","exitCode":0,"at":1786620000478}

package/tmp/worker-control/rollbridge-bootstrap/current-head-review-transcript.jsonl

@@ -0,0 +1 @@
+{"version":1,"type":"delegated_result","state":"completed","exitCode":0,"conclusion":"I’ll perform a read-only review of the full uncommitted diff, then trace the daemon bootstrap lifecycle through its existing implementation and focused tests. I’ll avoid edits and the full test suite, and report only material, reproducible issues—or `PASS`.The repaired state preservation path is present, and the focused tests cover the two accepted lifecycle fixes. I’m now checking concurrency boundaries beneath `deploy()`—especially whether `ReleaseGroup.start()` and process/service startup remain safely stoppable when shutdown overlaps activation—and validating persistence shape compatibility.- High — [src/daemon.js:747](/home/dev/rollbridge/src/daemon.js:747): shutdown snapshots `services`, `singletons`, and `startingReleases` only once, while the concurrent bootstrap deployment can continue creating processes. `ReleaseGroup.start()` has no cancellation check inside its process/replica loop ([src/release-group.js:73](/home/dev/rollbridge/src/release-group.js:73)), and singleton replacement similarly continues after each await ([src/daemon.js:539](/home/dev/rollbridge/src/daemon.js:539)). If SIGTERM arrives while an early service, companion replica, or singleton is starting/stopping, shutdown may finish its snapshot while deployment starts a later process. The signal handler then calls `process.exit(0)` ([src/cli.js:44](/home/dev/rollbridge/src/cli.js:44)), potentially leaving that detached child running and unrecorded. The new signal test only uses one release process and signals during its health wait, so it does not cover this realistic multi-process race.","continuationHandle":"019ffad7-bed8-7861-911f-83cd5de11373"}

package/tmp/worker-control/rollbridge-bootstrap/fs-probe-10.jsonl

@@ -0,0 +1 @@
+probe\n

package/tmp/worker-control/rollbridge-bootstrap/plan.md

@@ -0,0 +1,9 @@
+# Rollbridge daemon bootstrap plan
+
+1. Add focused CLI/daemon bootstrap tests first, covering all-or-nothing and safe absolute input validation before binding, exact activation through the normal deploy path, structured failure with attempt-owned cleanup and non-zero exit, unchanged plain-daemon startup, and preservation/reporting of live `statePath` orphans.
+2. Run the new focused test file alone and record the expected RED result before production changes.
+3. Add the minimal foreground daemon bootstrap options and validation, then start listeners and call the existing `RollbridgeDaemon.deploy()` path; on activation failure, log a safe structured failure, shut down only objects owned by this attempt, and propagate failure.
+4. Update the CLI reference and README daemon usage, then run the changed focused test files individually, `npm run lint`, and `npm run typecheck`.
+5. Inspect the final diff/status and leave every change uncommitted for independent verification.
+
+Scope note: bootstrap requires explicit `--release-path`, `--release-id`, and `--revision` together with an explicit `--config`; values must be non-empty safe tokens where applicable and paths must be absolute, normalized, and usable. No orphan recovery or process killing is part of bootstrap.

package/tmp/worker-control/rollbridge-bootstrap/repair-activity.jsonl

@@ -0,0 +1,3 @@
+{"type":"controller-started","pid":23,"at":1786619408071}
+{"type":"provider-started","provider":"codex","pid":34,"at":1786619408074}
+{"type":"terminal","provider":"codex","state":"failed","exitCode":2,"at":1786619520214}

package/tmp/worker-control/rollbridge-bootstrap/repair-fresh-activity.jsonl

@@ -0,0 +1,25 @@
+{"type":"controller-started","pid":23,"at":1786619544825}
+{"type":"provider-started","provider":"codex","pid":34,"at":1786619544829}
+{"type":"session-available","provider":"codex","sessionId":"019ffad2-c71a-7522-9645-c45214c2ba90","at":1786619545505}
+{"type":"activity","provider":"codex","kind":"lifecycle","at":1786619545506}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619552059}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619560395}
+{"type":"activity","provider":"codex","kind":"delta","at":1786619567749}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619582034}
+{"type":"activity","provider":"codex","kind":"delta","at":1786619609721}
+{"type":"activity","provider":"codex","kind":"delta","at":1786619632612}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619657491}
+{"type":"activity","provider":"codex","kind":"delta","at":1786619692967}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619698926}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619706811}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619724983}
+{"type":"activity","provider":"codex","kind":"delta","at":1786619730097}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619736678}
+{"type":"activity","provider":"codex","kind":"delta","at":1786619742798}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619748670}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619754672}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619764194}
+{"type":"activity","provider":"codex","kind":"delta","at":1786619775649}
+{"type":"activity","provider":"codex","kind":"tool","at":1786619780713}
+{"type":"activity","provider":"codex","kind":"delta","at":1786619786176}
+{"type":"terminal","provider":"codex","state":"completed","exitCode":0,"at":1786619829038}

package/tmp/worker-control/rollbridge-bootstrap/repair-fresh-transcript.jsonl

@@ -0,0 +1 @@
+{"version":1,"type":"delegated_result","state":"completed","exitCode":0,"conclusion":"I’ll resume in place and preserve the current worktree. I’ll first inspect the branch, repository guidance, lifecycle code, and existing tests; then I’ll add only focused deterministic regressions and capture their expected failures before touching production code.The root conflict is confirmed: startup reads prior live PIDs into an advisory in-memory list, but the first persistence snapshot deliberately drops that list, and shutdown then unconditionally removes the file. I’m going to make the regressions assert two boundaries directly: SIGTERM while bootstrap activation is provably in-flight, and recoverable prior PID records after bootstrap persistence plus shutdown/failure.The focused regressions are now in place without timing sleeps: the signal test gates on the daemon’s own “control socket listening” milestone, and persistence checks decode the actual state store through `liveProcesses`. I’m running only the bootstrap test file now to record the RED failures before production edits.RED is confirmed with exactly the three expected failures: bootstrap SIGTERM exits by signal instead of code 0, and both successful-shutdown and failed-activation paths lose the prior PID record. I’m now making the minimal ownership changes: register signal handling before activation, track the in-progress release as daemon-owned for shutdown, and carry advisory orphan records through snapshots and clean shutdown.The focused file is GREEN. I’m tightening the signal regression before final checks so it proves the managed child was actually started and then stopped—not just that the CLI intercepted SIGTERM early. The test will use a filesystem watch/marker handshake from the existing fixture, still with no sleeps or polling.The strengthened regression is GREEN and confirms the exact started PID received the daemon’s graceful stop before the CLI exited. The focused persistence regressions also remain GREEN. I’m moving to the requested static checks now, without running the full suite.`npm run lint` reached its bundled typecheck and found one narrow test typing issue: the async iterator’s optional `return` method. I’ve corrected that optional call and will re-run the focused test before repeating the requested checks.All requested test and static checks are now passing. I made one small documentation clarification because the durability behavior is operator-visible: live advisory orphan records remain in `statePath` for explicit recovery. I’m doing the final whitespace, diff, branch, and worktree inspection now; I will leave the existing `tmp/` and all unrelated candidate changes untouched.Implemented both HIGH lifecycle fixes on `feature/daemon-bootstrap-release`:\n\n- SIGINT/SIGTERM ownership is installed before bootstrap activation.\n- In-progress releases are daemon-owned and stopped during shutdown.\n- Prior-daemon orphan PID records remain persisted across snapshots, successful shutdown, and failed bootstrap activation.\n- Added deterministic regressions using explicit process/file handshakes—no sleeps or retries.\n- Updated documentation to describe recoverable orphan records.\n\nRED was confirmed with three expected failures before production edits. Final checks:\n\n- `node --test test/daemon-bootstrap.test.js` — 12 passed\n- `npm run lint` — passed\n- `npm run typecheck` — passed\n- `git diff --check` — passed\n\nFinal branch/status inspected. No full suite, commit, push, or deploy performed. Existing unrelated changes and `tmp/` remain untouched.","continuationHandle":"019ffad2-c71a-7522-9645-c45214c2ba90"}

package/tmp/worker-control/rollbridge-bootstrap/repair-transcript.jsonl

@@ -0,0 +1 @@
+{"version":1,"type":"delegated_result","state":"failed","exitCode":2,"continuationHandle":"019ffac6-1176-7023-8f14-82bae745817f"}