centralu 0.1.0-beta.47 → 0.1.0-beta.48

package/bin/serve-detach.mjs

@@ -267,6 +267,8 @@ export async function runDetachedChild({ spec, ...opts }) {
  * A stop that went through is remembered in the data folder (`markStopped`, #1143), so a linked hub does not start the
  * host again by itself; the next host that starts here removes the mark. Not for a hub's own stop, which starts the
  * host again itself (an update, a rollback): the hub runs it with `CENTRALU_STOP_BY=hub` (links/tunnel.ts `stopCommand`).
+ * The window's "Quit completely" on this host runs it with `CENTRALU_STOP_BY=quit` (#1466), so the mark says the person quit
+ * Centralu there, as the app's own host's does, not that they ran `serve --stop`.
  * With `CENTRALU_STOP_FOR=update` too (#1618), the host is asked to list the turns it ends, which the next host continues
  */
 export async function runStop({
@@ -281,6 +283,6 @@ export async function runStop({
 }) {
   const dataDir = serveDataDir(env, home)
   const stopped = await stopServedHost({ dataDir, entry, platform, forUpdate: env.CENTRALU_STOP_FOR === 'update', timeoutMs, graceMs, kill })
-  if (stopped.ok && env.CENTRALU_STOP_BY !== 'hub') markStopped(dataDir, 'stop')
+  if (stopped.ok && env.CENTRALU_STOP_BY !== 'hub') markStopped(dataDir, env.CENTRALU_STOP_BY === 'quit' ? 'quit' : 'stop')
   return answerLine(write, 'stop', stopped)
 }

package/bin/serve-handover.mjs

@@ -26,7 +26,7 @@ import { isAlive, say, sleep, waitUntil } from './serve-util.mjs'
  * And only a host `serve` started (`startedByServe`, #1722): a lock held by the app's or the keeper's host is theirs,
  * whatever answers on the port, so `--stop` says whose it is and leaves it.
  *
- * `{ ok, wasRunning, how?, message? }`, the `--stop` line's `stop`. With `ifIdle` (#1224, the hand-over) the host stops only
+ * `{ ok, wasRunning, how?, heldByOther?, message? }`, the `--stop` line's `stop`. With `ifIdle` (#1224, the hand-over) the host stops only
  * when nothing runs there, and `{ ok: false, busy: true }` says it did not. `forUpdate` (#1618): a hub's update stops it, and
  * the host writes the turns it ends for the next one (`host.stop { forUpdate }`); a host that does not take the request is
  * ended as any is, and lists nothing.
@@ -45,7 +45,8 @@ export async function stopServedHost({ dataDir, entry, platform = process.platfo
     // The folder is held, but not by a serve (#1722): the app's or the keeper's host, whatever answered on the port
     const other = foreignHolder(dataDir)
     const whose = other ? `. It belongs to another Centralu host (pid ${other.pid}), ${holderWho(other.by)}; not stopping it` : ''
-    return { ok: true, wasRunning: false, message: `centralu serve is not running for ${dataDir}${whose}` }
+    // `heldByOther`: the folder is held by a host that is not this serve's, which this left alone (the window's quit says so rather than claim a stop)
+    return { ok: true, wasRunning: false, ...(other ? { heldByOther: true } : {}), message: `centralu serve is not running for ${dataDir}${whose}` }
   }
 
   const hostPid = lockHolderPid(dataDir)

package/bin/serve-window.mjs

@@ -7,7 +7,7 @@
 import { join } from 'node:path'
 import { pairServe, readServeState } from './serve-files.mjs'
 import { DEFAULT_SERVE_PORT } from './serve-port.mjs'
-import { probeHost, protocolVersionOf } from './serve-host.mjs'
+import { askHostRpc, probeHost, protocolVersionOf } from './serve-host.mjs'
 import { serveFolder } from './serve-run.mjs'
 import { runDetach } from './serve-detach.mjs'
 import { startInSignIn } from './serve-autostart.mjs'
@@ -27,6 +27,9 @@ import { say, sleep } from './serve-util.mjs'
  *   (`moveIntoSignIn`, serve-handover.mjs).
  * - stdin is the window (it runs this with stdin a pipe): when it ends, this exits 0 and leaves the host running,
  *   since it serves the hub's link too.
+ * - A line `{"op":"system-ending"}` on that stdin (`"cancelled":true` calls it off) is the window saying the system is ending, a
+ *   shutdown, restart or sign-out (#1970): the host this runs is no child of the window and hears nothing of it, so this tells it by
+ *   `host.systemEnding`, with the window's full credential. A sign-out (`"logoff":true`) is not told to a host in a network logon, which it does not end.
  * - The host stops answering for `misses` polls in a row (the hand-over's gap, or it ended): this exits 1, and the
  *   window's supervisor starts this again, which finds the new host or starts one.
  *
@@ -45,6 +48,7 @@ export async function runWindow({
   signIn = startInSignIn,
   pollMs = 5_000,
   misses = 3,
+  ask = askHostRpc,
 }) {
   const { dataDir } = serveFolder({ env, home, cliPath, platform })
   const protocolVersion = protocolVersionOf(entry) ?? 0
@@ -82,6 +86,16 @@ export async function runWindow({
   const state = readServeState(dataDir)
   write(`${JSON.stringify({ ready: true, port: state.port ?? DEFAULT_SERVE_PORT, token, db: join(dataDir, 'store.db') })}\n`)
 
+  const tellEnding = async (line) => {
+    const op = parseLine(line)
+    if (op?.op !== 'system-ending') return
+    // A sign-out does not end a host the ssh logon of a hub started: it runs on
+    if (op.logoff === true && op.cancelled !== true && (await probe()).logon === 'network') return
+    const { port, proofKey } = readServeState(dataDir) ?? {}
+    const sent = await ask({ port: port ?? DEFAULT_SERVE_PORT, token, proofKey, protocolVersion, method: 'host.systemEnding', params: op.cancelled === true ? { cancelled: true } : {} })
+    if (!sent) say('the host did not take the notice that the system is ending')
+  }
+
   return await new Promise((resolve) => {
     let done = false
     const finish = (code) => {
@@ -89,6 +103,9 @@ export async function runWindow({
       done = true
       resolve(code)
     }
+    // One after the other: the call-off must not overtake the notice it calls off
+    let told = Promise.resolve()
+    stdin.on('data', lineReader((line) => void (told = told.then(() => tellEnding(line)).catch(() => {}))))
     stdin.once('end', () => finish(0))
     stdin.once('close', () => finish(0))
     stdin.resume()
@@ -114,3 +131,17 @@ function parseLine(text) {
     return null
   }
 }
+
+/** A `data` handler that gives `onLine` each complete line of the stream, however its chunks cut them */
+function lineReader(onLine) {
+  let rest = ''
+  return (chunk) => {
+    rest += String(chunk)
+    let i
+    while ((i = rest.indexOf('\n')) >= 0) {
+      onLine(rest.slice(0, i))
+      rest = rest.slice(i + 1)
+    }
+    if (rest.length > 64 * 1024) rest = ''
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "centralu",
-  "version": "0.1.0-beta.47",
+  "version": "0.1.0-beta.48",
   "description": "Run, watch and steer several Claude Code and Codex CLI sessions from one window",
   "license": "MIT",
   "author": "ijun17",
@@ -38,9 +38,9 @@
     "win32"
   ],
   "optionalDependencies": {
-    "@centralu/darwin-arm64": "0.1.0-beta.47",
-    "@centralu/linux-arm64": "0.1.0-beta.47",
-    "@centralu/linux-x64": "0.1.0-beta.47",
-    "@centralu/win32-x64": "0.1.0-beta.47"
+    "@centralu/darwin-arm64": "0.1.0-beta.48",
+    "@centralu/linux-arm64": "0.1.0-beta.48",
+    "@centralu/linux-x64": "0.1.0-beta.48",
+    "@centralu/win32-x64": "0.1.0-beta.48"
   }
 }