centralu 0.1.0-beta.30 → 0.1.0-beta.31

package/bin/serve-autostart.mjs

@@ -194,10 +194,18 @@ export function taskScript(action, { name, run = '', legacy = null }) {
   const head = ["$ErrorActionPreference = 'Stop'", PS_MODULE_PATH, '[Console]::OutputEncoding = [Text.Encoding]::UTF8', `$name = ${psText(name)}`]
   const fail = `} catch { "${TASK_WORD}-ERROR $($_.Exception.Message -replace '\\s+', ' ')" }`
   const find = "$t = Get-ScheduledTask -TaskName $name -TaskPath '\\' -ErrorAction SilentlyContinue"
-  // Whether a task's principal is this user's, as this serve registers it. Task Scheduler gives the id with or without the domain
+  /*
+   * Who this user is: their account's SID, and its name as Windows resolves it (`PC\user`, `DOMAIN\user`), which a task
+   * principal is registered with. Never USERDOMAIN: in an ssh logon on a PC in a workgroup it says `WORKGROUP`, which
+   * names no account (#1223, measured on a laptop with beta.30). Whether a task's principal is this user's, as this
+   * serve registers it, is decided by SID too: Task Scheduler gives the id with the domain, without it, or as a SID
+   */
   const mine = [
-    '$me = if ($env:USERDOMAIN) { "$env:USERDOMAIN\\$env:USERNAME" } else { $env:USERNAME }',
-    "function Test-Mine($x) { $x -and $x.Principal -and ($x.Principal.UserId -eq $me -or $x.Principal.UserId -eq $env:USERNAME) -and \"$($x.Principal.LogonType)\" -eq 'Interactive' -and \"$($x.Principal.RunLevel)\" -eq 'Limited' }",
+    '$account = [System.Security.Principal.WindowsIdentity]::GetCurrent()',
+    '$sid = $account.User.Value',
+    '$me = $account.Name',
+    "function Get-Sid($n) { if (\"$n\" -match '^S-1-') { return \"$n\" }; if (-not \"$n\") { return $null }; try { (New-Object System.Security.Principal.NTAccount(\"$n\")).Translate([System.Security.Principal.SecurityIdentifier]).Value } catch { $null } }",
+    "function Test-Mine($x) { $x -and $x.Principal -and ((Get-Sid $x.Principal.UserId) -eq $sid) -and \"$($x.Principal.LogonType)\" -eq 'Interactive' -and \"$($x.Principal.RunLevel)\" -eq 'Limited' }",
   ]
   const old = legacy
     ? [`$legacy = ${psText(legacy)}`, "$old = Get-ScheduledTask -TaskName $legacy -TaskPath '\\' -ErrorAction SilentlyContinue"]
@@ -238,15 +246,21 @@ export function taskScript(action, { name, run = '', legacy = null }) {
   if (action === 'signin') {
     /*
      * Someone is signed in when this user owns an Explorer in a session of its own (not session 0, where an ssh
-     * logon's processes run). Asked of WMI for the owner, which needs no administrator for the user's own processes
-     * and reads the same in every language
+     * logon's processes run). Asked of WMI for the owner's SID, which needs no administrator for the user's own
+     * processes, reads the same in every language, and does not depend on what this logon calls its domain (GetOwner's
+     * domain is the PC's name for a local account, while an ssh logon's USERDOMAIN may say `WORKGROUP`). When none is
+     * found, how many desktop Explorers there were at all, and how many of their owners WMI would not tell, goes into
+     * serve.log's line
      */
     return [
       ...head,
       'try {',
       ...mine.map((l) => `  ${l}`),
-      "  $desk = @(Get-CimInstance Win32_Process -Filter \"Name='explorer.exe'\" | Where-Object { $_.SessionId -gt 0 } | Where-Object { $o = Invoke-CimMethod -InputObject $_ -MethodName GetOwner; $o.ReturnValue -eq 0 -and $o.User -eq $env:USERNAME -and (-not $env:USERDOMAIN -or $o.Domain -eq $env:USERDOMAIN) })",
-      `  if ($desk.Count -eq 0) { '${TASK_WORD} nosession' } else {`,
+      "  $all = @(Get-CimInstance Win32_Process -Filter \"Name='explorer.exe'\" | Where-Object { $_.SessionId -gt 0 })",
+      '  $owners = @($all | ForEach-Object { Invoke-CimMethod -InputObject $_ -MethodName GetOwnerSid })',
+      '  $desk = @($owners | Where-Object { $_.ReturnValue -eq 0 -and $_.Sid -eq $sid })',
+      '  $unread = @($owners | Where-Object { $_.ReturnValue -ne 0 }).Count',
+      `  if ($desk.Count -eq 0) { "${TASK_WORD} nosession desktops=$($all.Count) unreadable=$unread" } else {`,
       ...[...want, ...old, find, dropOld].map((l) => `    ${l}`),
       '    $acts = @(if ($t) { $t.Actions })',
       '    $same = (Test-Mine $t) -and $acts.Count -eq 1 -and $acts[0].Execute -eq $exe -and $acts[0].Arguments -eq $arg',
@@ -409,7 +423,9 @@ async function taskAutostart(action, { dataDir, env, home, name, run, user, plat
  * network logon, which cannot open the user's Credential Manager vault, runs elevated for an administrator (#702) and
  * opens what it shows in session 0, where nobody sees it.
  *
- * `{ started: true, name }`, or `{ started: false, reason, message? }`: `nosession` (nobody is signed in here),
+ * `{ started: true, name }`, or `{ started: false, reason, message?, desktops? }`: `nosession` (this user is not signed
+ * in here; `desktops` is how many desktop Explorers, of any account, there were, `unreadable` how many of their owners
+ * WMI would not tell),
  * `off` (`CENTRALU_SIGNIN_TASK=off`, for a person who wants no task, and for tests on a machine with a desktop),
  * `not_windows`, `no_launcher`, `error`. `run` is a parameter so tests never reach the real Task Scheduler.
  */
@@ -422,10 +438,14 @@ export async function startInSignIn({ dataDir, env, home, platform = process.pla
   if (!ps) return { started: false, reason: 'error', message: 'Windows PowerShell is not reachable' }
   const name = autostartName('task', { dataDir, home, env, platform, user })
   const runScript = taskActionScript({ how: 'wmi', launcher, env })
-  const a = await askPowershell(ps, taskScript('signin', { name, run: runScript, legacy: legacyTaskName({ dataDir, home, env, platform }) }), env, parseTaskAnswer, run)
+  const parse = (out) => {
+    const m = /nosession desktops=(\d+)(?: unreadable=(\d+))?/.exec(String(out ?? ''))
+    return { ...parseTaskAnswer(out), ...(m ? { desktops: Number(m[1]), unreadable: Number(m[2] ?? 0) } : {}) }
+  }
+  const a = await askPowershell(ps, taskScript('signin', { name, run: runScript, legacy: legacyTaskName({ dataDir, home, env, platform }) }), env, parse, run)
   if (!a.ok) return { started: false, reason: 'error', message: a.message }
   if (a.word === 'started') return { started: true, name }
-  if (a.word === 'nosession') return { started: false, reason: 'nosession' }
+  if (a.word === 'nosession') return { started: false, reason: 'nosession', ...(a.desktops !== undefined ? { desktops: a.desktops, unreadable: a.unreadable } : {}) }
   return { started: false, reason: 'error', message: `Task Scheduler answered ${a.word}` }
 }
 

package/bin/serve-detach.mjs

@@ -3,11 +3,11 @@
  * stopping it in order (docs/plans/remote-hub.md §10.4).
  */
 import { spawn } from 'node:child_process'
-import { existsSync, openSync, renameSync, writeSync } from 'node:fs'
+import { existsSync, openSync, rmSync, writeFileSync, writeSync } from 'node:fs'
 import { userInfo } from 'node:os'
 import { join } from 'node:path'
 import { answerLine, isAlive, say, sayTo, runCaptured, tail, sleep } from './serve-util.mjs'
-import { SERVE_LOG_FILE, serveDataDir, ensureServeState } from './serve-files.mjs'
+import { SERVE_LOG_FILE, serveDataDir, ensureServeState, markStopped, rotateServeLog } from './serve-files.mjs'
 import { askPowershell, detachHow, windowsArg, wmiScript, parseWmiAnswer, wmiBlockedMessage, windowsPowershell, windowsTool, wslDistro, wslUser } from './serve-windows.mjs'
 import { CHILD_FLAG } from './serve-args.mjs'
 import { startInSignIn } from './serve-autostart.mjs'
@@ -22,20 +22,24 @@ import { describe, runServe, serveFolder } from './serve-run.mjs'
  */
 export const CARRIED_ENV = ['CC_DATA_DIR', 'CENTRALU_HOST_ENTRY', 'CENTRALU_MANAGED', 'CENTRALU_STARTED_FROM']
 
-export function encodeChildSpec({ env, log }) {
+/**
+ * `start` is how the launcher was started and why (`through WMI: <reason>`), which it writes into its first serve.log
+ * line, so a host that ended up outside the Windows sign-in says why (#1223)
+ */
+export function encodeChildSpec({ env, log, start = null }) {
   const carried = {}
   for (const k of CARRIED_ENV) if (typeof env[k] === 'string' && env[k]) carried[k] = env[k]
-  return Buffer.from(JSON.stringify({ log, env: carried }), 'utf8').toString('base64url')
+  return Buffer.from(JSON.stringify({ log, env: carried, ...(start ? { start } : {}) }), 'utf8').toString('base64url')
 }
 
-/** `{ log, env }` from `--detached-child=`, only the carried variables; null when it is not one */
+/** `{ log, env, start? }` from `--detached-child=`, only the carried variables; null when it is not one */
 export function decodeChildSpec(raw) {
   try {
     const v = JSON.parse(Buffer.from(String(raw), 'base64url').toString('utf8'))
     if (typeof v?.log !== 'string' || !v.log) return null
     const env = {}
     for (const k of CARRIED_ENV) if (typeof v.env?.[k] === 'string') env[k] = v.env[k]
-    return { log: v.log, env }
+    return { log: v.log, env, ...(typeof v.start === 'string' && v.start ? { start: v.start } : {}) }
   } catch {
     return null
   }
@@ -135,40 +139,52 @@ export async function runDetach({
   }
   if (await answered(true)) return 0
 
+  const log = join(dataDir, SERVE_LOG_FILE)
+  /*
+   * One start per log: the earlier ones are kept beside it, three of them (`rotateServeLog`, #1143), and its absence is
+   * how a start that never ran shows. So a log that cannot be moved aside is removed rather than left to read as a start
+   */
+  const freshLog = () => rotateServeLog(log)
+
   /*
    * Windows: in the person's sign-in when someone is signed in (#1224), through the scheduled task, and through WMI only
    * when nobody is. WMI's process keeps this ssh session's network logon, where Git cannot use the credentials saved in
    * Windows. A task-started host that does not answer in time is left to the lock: the WMI start below then either
-   * holds the folder or is refused by it, never a second host on it.
+   * holds the folder or is refused by it, never a second host on it. Which way it went, and why, is one line of
+   * serve.log (#1223): the task's serve writes no serve.log, so that line is written here; a WMI launcher writes its own
    */
+  let notInSignIn = null
   if (how === 'wmi') {
     const s = await signIn({ dataDir, env, home, platform })
     if (s.started) {
-      say(`started centralu serve in the Windows sign-in (the scheduled task "${s.name}"); waiting for its host`)
+      const line = `started centralu serve in the Windows sign-in (the scheduled task "${s.name}"); waiting for its host`
+      say(line)
+      freshLog()
+      try {
+        writeFileSync(log, `[centralu serve] ${line}\n`)
+      } catch {
+        // the line on stderr is all there is
+      }
       const t0 = Date.now()
       while (Date.now() - t0 < signInMs) {
         if (await answered(false, 'task')) return 0
         await sleep(250)
       }
-      say(`the host the sign-in task started did not answer within ${Math.round(signInMs / 1000)} s; starting one through WMI instead`)
-    } else if (s.reason === 'nosession') {
-      say('nobody is signed in to Windows here: starting the host through WMI, outside any sign-in, where Git cannot use the credentials saved in Windows')
-    } else if (s.reason === 'error') {
-      say(`could not start the host in the Windows sign-in (${s.message}); starting it through WMI`)
+      notInSignIn = `the host the sign-in task "${s.name}" started did not answer within ${Math.round(signInMs / 1000)} s`
+      // The WMI launcher's first line says so; the task's line goes, so `serve.log.1` keeps the start before this one
+      rmSync(log, { force: true, maxRetries: 5 })
+    } else {
+      notInSignIn = signInMissed(s)
     }
+    say(`${notInSignIn}: starting the host through WMI${s.reason === 'nosession' ? ', outside any sign-in, where Git cannot use the credentials saved in Windows' : ''}`)
   }
 
-  const log = join(dataDir, SERVE_LOG_FILE)
-  // One start per log: the last one's is kept beside it, and its absence is how a start that never ran shows
-  try {
-    renameSync(log, `${log}.1`)
-  } catch {
-    // there was none
-  }
+  freshLog()
   // Where this was asked for from (#1223): the launcher runs outside this ssh session, so it is told
   const asked = serveFrom(env, from)
   const childEnv = asked ? { ...env, CENTRALU_STARTED_FROM: JSON.stringify(asked) } : env
-  const args = [cliPath, 'serve', ...(port !== null ? ['--port', String(port)] : []), `${CHILD_FLAG}${encodeChildSpec({ env: childEnv, log })}`]
+  const startedHow = `through ${how === 'wmi' ? 'WMI' : how === 'wsl' ? 'a WMI-created wsl.exe' : how}${notInSignIn ? `: ${notInSignIn}` : ''}`
+  const args = [cliPath, 'serve', ...(port !== null ? ['--port', String(port)] : []), `${CHILD_FLAG}${encodeChildSpec({ env: childEnv, log, start: startedHow })}`]
   let started
   try {
     started = await start({ how, execPath, args, env, cwd })
@@ -198,6 +214,26 @@ export async function runDetach({
   return fail('timeout', `the host did not answer within ${Math.round(timeoutMs / 1000)} s${why ? `:\n${why}` : ''}`)
 }
 
+/** Why the host was not started in the Windows sign-in, from `startInSignIn`'s answer, for serve.log and stderr */
+export function signInMissed(s) {
+  if (s.reason === 'nosession') {
+    const n = s.desktops
+    const unread = s.unreadable ? `, ${s.unreadable} of them with an owner WMI would not tell` : ''
+    const seen =
+      typeof n !== 'number'
+        ? 'no Explorer of this account in a desktop session'
+        : n === 0
+          ? 'no Explorer in any desktop session'
+          : `none of the ${n} Explorer${n === 1 ? '' : 's'} in desktop sessions is this account's${unread}`
+    return `no Windows sign-in of this user was found (${seen})`
+  }
+  // It travels on the launcher's command line: bounded
+  if (s.reason === 'error') return `the sign-in task failed: ${String(s.message).slice(0, 300)}`
+  if (s.reason === 'off') return 'the sign-in task is turned off (CENTRALU_SIGNIN_TASK=off)'
+  if (s.reason === 'no_launcher') return 'there is no launcher in the data folder for the sign-in task to run'
+  return `the sign-in task was not used (${s.reason})`
+}
+
 /**
  * The launcher `--detach` started: `runServe` writing to serve.log. The carried variables are
  * already in `env` (centralu.mjs merges them before it looks for the host).
@@ -216,7 +252,8 @@ export async function runDetachedChild({ spec, ...opts }) {
   } catch {
     // no log: say() keeps stderr, which nobody reads; --detach then reports the start as never run
   }
-  say(`started in the background (pid ${process.pid}, Node ${process.version})`)
+  // One line saying how it was started and why (#1223), and what runs
+  say(`started in the background${spec.start ? ` ${spec.start}` : ''} (pid ${process.pid}, Node ${process.version})`)
   try {
     return await runServe({ ...opts, logFd: fd })
   } catch (e) {
@@ -230,6 +267,10 @@ export async function runDetachedChild({ spec, ...opts }) {
  * socket, and waited for (`stopServedHost` in serve-handover.mjs, which the hand-over into the sign-in shares, #1224).
  *
  * stdout: one line, `{ v: 1, stop: { ok, wasRunning, how?, message? } }`.
+ *
+ * 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`)
  */
 export async function runStop({
   env,
@@ -242,5 +283,7 @@ export async function runStop({
   write = (line) => process.stdout.write(line),
 }) {
   const dataDir = serveDataDir(env, home)
-  return answerLine(write, 'stop', await stopServedHost({ dataDir, entry, platform, timeoutMs, graceMs, kill }))
+  const stopped = await stopServedHost({ dataDir, entry, platform, timeoutMs, graceMs, kill })
+  if (stopped.ok && env.CENTRALU_STOP_BY !== 'hub') markStopped(dataDir, 'stop')
+  return answerLine(write, 'stop', stopped)
 }

package/bin/serve-files.mjs

@@ -5,9 +5,9 @@
  */
 import { execFileSync } from 'node:child_process'
 import { randomBytes } from 'node:crypto'
-import { chmodSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeSync, closeSync } from 'node:fs'
+import { chmodSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeSync, closeSync } from 'node:fs'
 import { join } from 'node:path'
-import { isAlive, replaceFile, sleepSync } from './serve-util.mjs'
+import { isAlive, renameRetrying, replaceFile, sleepSync } from './serve-util.mjs'
 
 /**
  * The file in the data folder that holds the token and the port, mode 0600.
@@ -25,6 +25,73 @@ export const SERVE_LOG_FILE = 'serve.log'
 /** The running launcher's pid and port, so `--stop` can find it. Removed when it exits */
 export const SERVE_PID_FILE = 'serve.pid'
 
+/** How many earlier starts' serve.log are kept, as serve.log.1 (the last) to serve.log.3 */
+export const SERVE_LOGS_KEPT = 3
+
+/**
+ * Makes room for a new start's serve.log (#1143): the earlier ones move down a place, and the oldest past
+ * `SERVE_LOGS_KEPT` goes. A hub that starts a host again after it stopped makes at most three starts in ten minutes,
+ * so the log of the start that failed first is still here when it stops trying. The last one is moved aside with
+ * `renameRetrying` (a reader may hold the file on Windows, #1223); one that cannot be moved is removed rather than
+ * left to read as the new start's. Never fatal
+ */
+export function rotateServeLog(log, kept = SERVE_LOGS_KEPT, rename = renameRetrying) {
+  // No log to move aside, no room to make: a second call for the same start (the task's line removed before a WMI start)
+  if (!existsSync(log)) return
+  for (let i = kept - 1; i >= 1; i--) {
+    try {
+      renameSync(`${log}.${i}`, `${log}.${i + 1}`)
+    } catch {
+      // there was none, or a reader holds it: the older log stays where it is
+    }
+  }
+  try {
+    rename(log, `${log}.1`)
+  } catch (e) {
+    if (e?.code === 'ENOENT') return
+    try {
+      rmSync(log, { force: true, maxRetries: 5 })
+    } catch {
+      // nothing more to do
+    }
+  }
+}
+
+/**
+ * The person's stop, kept in the data folder (#1143): `centralu serve --stop` writes it (`by: 'stop'`), and so does a
+ * host that Centralu's own app stops for good when the person quits it there (`by: 'quit'`, the host's
+ * lifecycle/stopped-mark.ts, which names the same file). Every host that starts in the folder removes it.
+ * `--connection` reports it while no host runs, and a hub then starts none by itself. A hub's own stop (an update)
+ * leaves none: it says so with `CENTRALU_STOP_BY=hub`
+ */
+export const SERVE_STOPPED_FILE = 'stopped.json'
+
+/** Writes the mark; never fatal, a stop that could not note itself still stopped */
+export function markStopped(dataDir, by, now = Date.now()) {
+  try {
+    replaceFile(join(dataDir, SERVE_STOPPED_FILE), `${JSON.stringify({ v: 1, by, at: now })}\n`)
+  } catch {
+    // the folder is read-only or gone: nothing to remember it in
+  }
+}
+
+/** The mark as `{ by, at }`, or null when there is none. One that does not parse is still a stop, by `stop`, at no time */
+export function readStopped(dataDir) {
+  let text
+  try {
+    text = readFileSync(join(dataDir, SERVE_STOPPED_FILE), 'utf8')
+  } catch {
+    return null
+  }
+  let o = null
+  try {
+    o = JSON.parse(text)
+  } catch {
+    // half written, or written by hand
+  }
+  return { by: o?.by === 'quit' ? 'quit' : 'stop', at: typeof o?.at === 'number' && Number.isFinite(o.at) ? o.at : null }
+}
+
 /** The data folder: the host's own rule (`dataRoot()` in agent-host), CC_DATA_DIR or ~/.centralu */
 export function serveDataDir(env, home) {
   return env.CC_DATA_DIR || join(home, '.centralu')

package/bin/serve-host.mjs

@@ -34,7 +34,7 @@ export function protocolVersionOf(entry) {
  * `install` (additive, the line stays `v: 1`) says what runs this command (`installInfo`); `detach`
  * is added by `--detach` only.
  */
-export function connectionLine({ port, token, version, protocolVersion, dataDir, hostRunning, install, autostart, detach, proof }) {
+export function connectionLine({ port, token, version, protocolVersion, dataDir, hostRunning, install, autostart, detach, proof, stopped }) {
   /*
    * The options this serve takes that an older one refuses (#1223): a hub adds `--from <its name>` to `--detach` only
    * when the line says so, since an older serve answers an option it does not know with an error. `window`: the
@@ -54,6 +54,8 @@ export function connectionLine({ port, token, version, protocolVersion, dataDir,
     ...(detach ? { detach } : {}),
     // The running host proves it holds the token before the hub sends it (#838); absent: the hub sends hello as before
     ...(proof ? { proof: true } : {}),
+    // The person stopped the host here, and when (#1143, `readStopped`); absent: an older serve, or no such stop
+    ...(stopped ? { stopped } : {}),
     takes,
   })
 }

package/bin/serve-run.mjs

@@ -4,7 +4,7 @@ import { writeFileSync, writeSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { createInterface } from 'node:readline'
 import { isAlive, say } from './serve-util.mjs'
-import { SERVE_STATE_FILE, SERVE_PID_FILE, serveDataDir, ensureServeState, recordServePort, rotateServeToken, heldHere, lockHolder, lockHolderPid, removeServePid } from './serve-files.mjs'
+import { SERVE_STATE_FILE, SERVE_PID_FILE, readStopped, serveDataDir, ensureServeState, recordServePort, rotateServeToken, heldHere, lockHolder, lockHolderPid, removeServePid } from './serve-files.mjs'
 import { DEFAULT_SERVE_PORT, SERVE_PORT_TRIES, chooseServePort, listensHere, windowsListening } from './serve-port.mjs'
 import { keepLauncher, installInfo } from './serve-install.mjs'
 import { protocolVersionOf, connectionLine, hostEnv, hostCommand, readyPort, hostProvesOf, probeHost, serveFrom, takesTokenOnStdin, tokenLine } from './serve-host.mjs'
@@ -31,6 +31,9 @@ export async function describe({ env, dataDir, state, entry, version }) {
   const probe = await probeHost({ port, token: state.token, protocolVersion: installed, prove: proof })
   const protocolVersion = (probe.running ? probe.protocolVersion : undefined) ?? installed
   if (protocolVersion === null) return null
+  const hostRunning = heldHere(probe, dataDir)
+  // The person stopped it here (#1143): said while no host runs, so a hub starts none by itself
+  const stopped = hostRunning ? null : readStopped(dataDir)
   return {
     proof,
     port,
@@ -38,9 +41,10 @@ export async function describe({ env, dataDir, state, entry, version }) {
     version: (probe.running ? probe.version : undefined) ?? version,
     protocolVersion,
     dataDir,
-    hostRunning: heldHere(probe, dataDir),
+    hostRunning,
     install: installInfo(dataDir, env),
     autostart: autostartInfo(dataDir, process.platform, env),
+    ...(stopped ? { stopped } : {}),
   }
 }
 

package/bin/serve.mjs

@@ -24,7 +24,7 @@
  * (`serve-autostart.mjs`), Windows, WSL and PowerShell (`serve-windows.mjs`), and small helpers
  * (`serve-util.mjs`).
  */
-export { SERVE_STATE_FILE, SERVE_LOG_FILE, SERVE_PID_FILE, serveDataDir, readServeState, ensureServeState, recordServePort, rotateServeToken, heldHere, lockHolderIsAlive, processStartTime, lockHolder, lockHolderPid, readServePid } from './serve-files.mjs'
+export { SERVE_STATE_FILE, SERVE_LOG_FILE, SERVE_PID_FILE, serveDataDir, readServeState, ensureServeState, recordServePort, rotateServeToken, heldHere, lockHolderIsAlive, processStartTime, lockHolder, lockHolderPid, readServePid, SERVE_STOPPED_FILE, SERVE_LOGS_KEPT, markStopped, readStopped, rotateServeLog } from './serve-files.mjs'
 export { detachHow, windowsArg, wmiScript, parseWmiAnswer, wmiBlockedMessage, windowsPowershell, ownLogon } from './serve-windows.mjs'
 export { DEFAULT_SERVE_PORT, SERVE_PORT_TRIES, chooseServePort, listensHere, parseNetstatListening } from './serve-port.mjs'
 export { SERVE_HELP, AUTOSTART_ACTIONS, parseServeArgs } from './serve-args.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "centralu",
-  "version": "0.1.0-beta.30",
+  "version": "0.1.0-beta.31",
   "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.30",
-    "@centralu/linux-arm64": "0.1.0-beta.30",
-    "@centralu/linux-x64": "0.1.0-beta.30",
-    "@centralu/win32-x64": "0.1.0-beta.30"
+    "@centralu/darwin-arm64": "0.1.0-beta.31",
+    "@centralu/linux-arm64": "0.1.0-beta.31",
+    "@centralu/linux-x64": "0.1.0-beta.31",
+    "@centralu/win32-x64": "0.1.0-beta.31"
   }
 }