jackherd 1.11.1 → 1.12.0

package/src/watch/watch-events.ts

@@ -30,6 +30,12 @@ import {
   type NoSignalState,
   type NoTaskSignalEvent,
 } from './task-signal-missing'
+import {
+  isUnlinkedState,
+  UNLINKED_ARTIFACT_EVENT,
+  type UnlinkedArtifactEvent,
+  type UnlinkedState,
+} from './unlinked-artifacts'
 import { RUN_EVENT, RUN_STATUS, type WorkflowRun } from './workflow-runs'
 
 /** The event `updateAvailableLine` prints; it is no `WatchEvent`, the announcer logs it on its own. */
@@ -51,6 +57,7 @@ export const WATCH_EVENT = {
   laneParallel: LANE_PARALLEL_EVENT,
   taskParallel: TASK_PARALLEL_EVENT,
   noTaskSignal: NO_TASK_SIGNAL_EVENT,
+  unlinkedArtifact: UNLINKED_ARTIFACT_EVENT,
   approval: APPROVAL_EVENT,
   source: SOURCE_EVENT,
   due: APPOINTMENT_EVENT.due,
@@ -109,6 +116,8 @@ export type WatchState = {
   parallelAutoEnded: string | null
   /** Per watched lane: since when it works without a task signal and the phase last reported as `no task signal`. */
   noTaskSignals: NoSignalState
+  /** Per open artifact send no plan or board links: in its grace or already reported as `unlinked artifact`. */
+  unlinkedArtifacts: UnlinkedState
   /** The ids of the approval requests on disk when they were last read, each reported once while it is open. */
   approvals: string[]
   /** Per configured source of `watch.sources`: the entries seen (`[id, fingerprint]`) and the start of a failure streak. */
@@ -166,6 +175,7 @@ export type WatchEvent =
   | LaneParallelEvent
   | TaskParallelEvent
   | NoTaskSignalEvent
+  | UnlinkedArtifactEvent
   | ApprovalEvent
   | SourceEvent
   | AppointmentEvent
@@ -203,6 +213,7 @@ export const emptyWatchState = (): WatchState => ({
   taskParallels: {},
   parallelAutoEnded: null,
   noTaskSignals: {},
+  unlinkedArtifacts: {},
   approvals: [],
   sources: emptySourceState(),
   reportMtimes: {},
@@ -252,6 +263,7 @@ const isWatchState = (value: Record<string, unknown>): value is WatchState =>
   isTaskParallelFingerprints(value.taskParallels) &&
   (value.parallelAutoEnded === null || typeof value.parallelAutoEnded === 'string') &&
   isNoSignalState(value.noTaskSignals) &&
+  isUnlinkedState(value.unlinkedArtifacts) &&
   Array.isArray(value.approvals) &&
   value.approvals.every((id) => typeof id === 'string') &&
   isSourceState(value.sources) &&

package/src/watch/watcher-lock.ts

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto'
-import { rmSync } from 'node:fs'
+import { readFileSync, rmSync } from 'node:fs'
 import { basename, dirname, join } from 'node:path'
 import { writePrivateFile } from '../../kit/hooks/hooks/shared/private-directory'
 import {
@@ -79,11 +79,51 @@ export const repositoryKey = (root: string): string => {
   return `${name}-${hash}`
 }
 
-const commandLineOf: CommandLineOf = (pid) => {
+/** How long the herd trusts a command line `ps` gave for a process ID that is still alive. */
+const PS_CACHE_MS = 30_000
+
+/** The command line from `/proc/<pid>/cmdline`, its arguments blank-separated; null where there is no `/proc` or no such process. */
+export const procCommandLine: CommandLineOf = (pid) => {
+  try {
+    return readFileSync(`/proc/${pid}/cmdline`, 'utf8').split('\0').filter(Boolean).join(' ') || null
+  } catch {
+    return null
+  }
+}
+
+const psCommandLine: CommandLineOf = (pid) => {
   const result = Bun.spawnSync(['ps', '-o', 'command=', '-p', String(pid)], { stdout: 'pipe', stderr: 'ignore' })
   return result.exitCode === 0 ? result.stdout.toString().trim() || null : null
 }
 
+/**
+ * `lookUp` with each found command line kept per process ID for `ttlMs`; a miss is asked again. Only for readers:
+ * a process ID is reused after its process ends, so what may be signalled is always looked up afresh.
+ */
+export const cachedCommandLineOf = (
+  lookUp: CommandLineOf,
+  ttlMs: number = PS_CACHE_MS,
+  clock: () => number = Date.now,
+): CommandLineOf => {
+  const found = new Map<number, { line: string; at: number }>()
+  return (pid) => {
+    const kept = found.get(pid)
+    if (kept && clock() - kept.at < ttlMs) return kept.line
+    const line = lookUp(pid)
+    if (line === null) found.delete(pid)
+    else found.set(pid, { line, at: clock() })
+    return line
+  }
+}
+
+/** `/proc` where it exists (no process started), else `ps`: what decides whom `takeOverLock` signals. */
+const commandLineOf: CommandLineOf = (pid) => procCommandLine(pid) ?? psCommandLine(pid)
+
+const cachedPsCommandLine = cachedCommandLineOf(psCommandLine)
+
+/** What the herd asks every few seconds: `/proc`, else `ps` kept per process ID, since one `ps` blocks for tens of milliseconds. */
+const readerCommandLineOf: CommandLineOf = (pid) => procCommandLine(pid) ?? cachedPsCommandLine(pid)
+
 const isAlive = (pid: number): boolean => {
   try {
     process.kill(pid, 0)
@@ -109,8 +149,11 @@ export const ensureWatcherDirectory = (root: string, system: LocationSystem = sy
   return ensurePrivateLevels(dirname(directory), directory)
 }
 
-/** Whether the lock names a live process that is a watcher, so its saved state is being kept up to date. */
-export const isWatcherRunning = (lockFile: string, lookUp: CommandLineOf = commandLineOf): boolean => {
+/**
+ * Whether the lock names a live process that is a watcher, so its saved state is being kept up to date. The process
+ * is checked to be alive on every call, so a kept command line never shows a watcher that has ended.
+ */
+export const isWatcherRunning = (lockFile: string, lookUp: CommandLineOf = readerCommandLineOf): boolean => {
   const pid = lockedPid(readPrivateText(lockFile))
   return pid !== null && isAlive(pid) && isWatcherCommand(lookUp(pid) ?? '')
 }