threadsState gives one row per session with `session` and `legacy`; threadIdle
idles a run against its bound session. Each session gets its own store
(threads/<b>/<t>/sessions/<s>/, or the thread's old store for a legacy-3l
session) and its own workspace (session-workspaces/<b>/<i>/<s>/), held by an
O_EXCL <ws>.lock from before the clones to the run's proven exit. A legacy
session's workspace binds in-sandbox at the old instance path. sessions.json
is v2 and reads v1. New tests: cli session-launch.test.mjs, seat
session-workspace.test.mjs. Not yet run: tests wait for Sage's CLEAR.
Two old assertions change as exact updates:
- mos-1285: end-launch.test.mjs threadsState deepEqual. The old row shape was
{ thread: 'th-1', instance: 'coder', pending: 0, unread: 0, lastMessage: null,
lastOpen: '2026-10-15T00:00:01.000Z', lastClaim: null, holder: null }; the
row keeps every key and value and adds session: 'th-1', legacy: true.
- mos-1289: thread-launch.test.mjs:182, old line
`const store = join(f.dataRoot, "threads", "acme", A);`
now reads A's default session id from threadsState's `session` key; :183-185
unchanged; one added assert that threads/acme/<A>/session is absent.
430 lines
21 KiB
JavaScript
430 lines
21 KiB
JavaScript
// Managed role sessions (slice 1 S6): where a launch lives on disk, how its
|
|
// runner starts, and how the human stops it. The bus host
|
|
// (packages/cli/src/launcher.mjs) is the only caller that starts one; it
|
|
// decides authority and capacity first, and this module only does what it
|
|
// is told.
|
|
//
|
|
// A session is `node packages/harness/src/runner.mjs <run dir>` inside the
|
|
// bubblewrap sandbox of sandbox.mjs, which sees only its own workspace, its
|
|
// run directory and the files it runs from. The runner is pid 1 of its own
|
|
// PID namespace, so a child that detaches (`setsid -f`) is reparented to the
|
|
// runner and stays under the launch's pid, which the human CLI's ancestry
|
|
// check refuses. bwrap passes the runner's exit status on, a death by signal
|
|
// as 128 + the signal; `stop` signals the runner.
|
|
//
|
|
// On disk, under the data root:
|
|
// launches/<business>/<run>/ the run directory (0700): session.json,
|
|
// bundle/, session/, turns/, runner.log,
|
|
// tools.sock, turn.done
|
|
// launches/<business>.jsonl the launch log (0600, append-only):
|
|
// every launch, refusal and end
|
|
// workspaces/<business>/<instance>/ the instance's workspace (0700), kept
|
|
// across launches
|
|
// threads/<business>/<thread>/ a legacy thread session's store (0700),
|
|
// kept across its runs (row 121):
|
|
// session/ and claude-projects/
|
|
// threads/<business>/<thread>/sessions/<session>/
|
|
// any other session's store (row 269)
|
|
// session-workspaces/<business>/<instance>/<session>/
|
|
// a thread session's workspace (0700),
|
|
// with <session>.lock beside it
|
|
// bus-host/sessions.json the running sessions (0600), written
|
|
// only by the host; `mosaic stop` reads it
|
|
|
|
import { spawn } from "node:child_process";
|
|
import { randomBytes } from "node:crypto";
|
|
import { appendFileSync, closeSync, existsSync, linkSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
|
|
import { constants } from "node:os";
|
|
import { dirname, join, sep } from "node:path";
|
|
import { childrenOf, cmdlineOf, startTimeOf } from "./proc.mjs";
|
|
import { binds, prepareRun, REPO, sandboxArgv } from "./sandbox.mjs";
|
|
import { SeatError } from "./seat.mjs";
|
|
import { ID_PATTERN } from "../../business/src/vocabulary.mjs";
|
|
|
|
export { REPO };
|
|
export const RUNNER = join(REPO, "packages", "harness", "src", "runner.mjs");
|
|
// Row 269 (264b): 2 adds `session` and `workspace` to a thread run's entry.
|
|
// readSessions still reads a version 1 file an earlier host left.
|
|
export const SESSIONS_VERSION = 2;
|
|
const SESSIONS_READ = [1, 2];
|
|
|
|
export const sessionsFile = (dataRoot) => join(dataRoot, "bus-host", "sessions.json");
|
|
export const launchSocketPath = (dataRoot) => join(dataRoot, "bus-host", "launch.sock");
|
|
// Row 93 (#1587): packages/cli/src/git-socket.mjs.
|
|
export const gitSocketPath = (dataRoot) => join(dataRoot, "bus-host", "git.sock");
|
|
export const runsDir = (dataRoot, business) => join(dataRoot, "launches", business);
|
|
export const launchLogFile = (dataRoot, business) => join(dataRoot, "launches", `${business}.jsonl`);
|
|
export const workspaceDir = (dataRoot, business, instance) => join(dataRoot, "workspaces", business, instance);
|
|
export const sessionWorkspaceDir = (dataRoot, business, instance, session) => join(dataRoot, "session-workspaces", business, instance, session);
|
|
|
|
// Row 121 (#1615): a thread's session store, which outlives each of the
|
|
// thread's runs so the next run resumes the harness session (REQ-THREAD-2).
|
|
// Both segments are checked before the join: an id, no "..", so no "/" and
|
|
// no leading ".". Then every directory from threads/ down must be ours, a
|
|
// real directory and private, as store.mjs safe() checks the bus. session/
|
|
// is the run's sessionDir; claude-projects/ is bound at the run's
|
|
// home/.claude/projects (sandbox.mjs binds()). Throws SeatError.
|
|
const segment = (x) => typeof x === "string" && ID_PATTERN.test(x) && !x.includes("..");
|
|
const seatError = (message, code) => Object.assign(new SeatError(message, 2), { code });
|
|
function segments(what, pairs, code) {
|
|
for (const [name, x] of pairs) {
|
|
if (!segment(x)) throw seatError(`${what}: ${name} ${JSON.stringify(x)} isn't an id`, code);
|
|
}
|
|
}
|
|
// Makes each directory in order, then checks it is ours, a real directory and private.
|
|
function privateDirs(what, dirs, code) {
|
|
for (const d of dirs) {
|
|
try {
|
|
mkdirSync(d, { mode: 0o700 });
|
|
} catch (e) {
|
|
if (e.code !== "EEXIST") throw e;
|
|
}
|
|
const st = lstatSync(d);
|
|
if (st.isSymbolicLink() || !st.isDirectory() || st.uid !== process.getuid() || st.mode & 0o077) throw seatError(`${what}: ${d} is unsafe`, code);
|
|
}
|
|
}
|
|
export function threadStore(dataRoot, business, thread) {
|
|
segments("thread store", [["business", business], ["thread", thread]], "thread-store-refused");
|
|
const dir = join(dataRoot, "threads", business, thread);
|
|
const out = { dir, session: join(dir, "session"), projects: join(dir, "claude-projects") };
|
|
privateDirs("thread store", [join(dataRoot, "threads"), join(dataRoot, "threads", business), dir, out.session, out.projects], "thread-store-refused");
|
|
return out;
|
|
}
|
|
|
|
// Row 269 (264b, #1774): one session's store. A legacy session (op legacy-3l,
|
|
// whose id is its thread's) keeps the thread's store, so its harness resumes
|
|
// the history it has; any other session gets its own under sessions/, with
|
|
// the same checks on every segment and directory. Same shape as threadStore.
|
|
// legacyThread: the thread has a legacy session. When it has none, a
|
|
// threads/<b>/<t>/session left by a 264a run of the thread's default session
|
|
// refuses legacy-store-unmapped, so that history isn't silently left behind.
|
|
export function sessionStore(dataRoot, business, thread, session, { legacy = false, legacyThread = legacy } = {}) {
|
|
if (legacy) return threadStore(dataRoot, business, thread);
|
|
segments("thread store", [["business", business], ["thread", thread], ["session", session]], "thread-store-refused");
|
|
const threadDir = join(dataRoot, "threads", business, thread);
|
|
if (!legacyThread) {
|
|
let old = true;
|
|
try {
|
|
lstatSync(join(threadDir, "session"));
|
|
} catch (e) {
|
|
if (e.code !== "ENOENT") throw e;
|
|
old = false;
|
|
}
|
|
if (old) throw seatError(`thread store: ${join(threadDir, "session")} holds history no legacy session maps`, "legacy-store-unmapped");
|
|
}
|
|
const dir = join(threadDir, "sessions", session);
|
|
const out = { dir, session: join(dir, "session"), projects: join(dir, "claude-projects") };
|
|
privateDirs("thread store", [join(dataRoot, "threads"), join(dataRoot, "threads", business), threadDir, join(threadDir, "sessions"), dir, out.session, out.projects], "thread-store-refused");
|
|
return out;
|
|
}
|
|
|
|
const inside = (a, b) => a === b || a.startsWith(b + sep);
|
|
const realOrNull = (p) => {
|
|
try {
|
|
return realpathSync(p);
|
|
} catch (e) {
|
|
if (e.code === "ENOENT") return null;
|
|
throw e;
|
|
}
|
|
};
|
|
// Row 269: a thread session's workspace, session-workspaces/<b>/<i>/<s>. Each
|
|
// segment is an id and each directory ours, real and private
|
|
// (session-workspace-unsafe). Then the realpaths: it may not be inside, or
|
|
// contain, the legacy workspaces root, its business and instance directories
|
|
// or any entry of either (old instance, .retired and task workspaces), nor
|
|
// sit above or below a `live` workspace (session-workspace-overlap). The same
|
|
// path as a live one is left to the lock, which refuses session-workspace-busy.
|
|
export function sessionWorkspace(dataRoot, business, instance, session, { live = [] } = {}) {
|
|
segments("session workspace", [["business", business], ["instance", instance], ["session", session]], "session-workspace-unsafe");
|
|
const root = join(dataRoot, "session-workspaces");
|
|
const path = join(root, business, instance, session);
|
|
privateDirs("session workspace", [root, join(root, business), join(root, business, instance), path], "session-workspace-unsafe");
|
|
const real = realpathSync(path);
|
|
const legacy = join(dataRoot, "workspaces");
|
|
const named = [legacy, join(legacy, business), join(legacy, business, instance)];
|
|
const entries = (d) => {
|
|
try {
|
|
return readdirSync(d).map((x) => join(d, x));
|
|
} catch (e) {
|
|
if (e.code === "ENOENT" || e.code === "ENOTDIR") return [];
|
|
throw e;
|
|
}
|
|
};
|
|
for (const p of [...named, ...entries(legacy), ...entries(join(legacy, business))]) {
|
|
const other = realOrNull(p);
|
|
if (other && (inside(real, other) || inside(other, real))) throw seatError(`session workspace: ${path} overlaps the legacy workspace ${p}`, "session-workspace-overlap");
|
|
}
|
|
for (const p of live) {
|
|
const other = realOrNull(p);
|
|
if (other && other !== real && (inside(real, other) || inside(other, real))) throw seatError(`session workspace: ${path} overlaps the live workspace ${p}`, "session-workspace-overlap");
|
|
}
|
|
return path;
|
|
}
|
|
|
|
// Row 269: the single-writer lock on a session workspace, <workspace>.lock,
|
|
// beside it and outside every mount. It names the host (pid, start time) and,
|
|
// once spawned, the run's outer process. A lock whose host and run are both
|
|
// gone is stale and is taken over; any other refuses session-workspace-busy.
|
|
// Returns { file, update(fields), release() }.
|
|
const lockAlive = (pid, start) => Number.isSafeInteger(pid) && pid > 0 && start != null && startTimeOf(pid) === start;
|
|
export function lockSessionWorkspace(workspace, owner) {
|
|
const file = `${workspace}.lock`;
|
|
let held = { ...owner };
|
|
const write = (flag) => writeFileSync(file, `${JSON.stringify(held)}\n`, { mode: 0o600, flag });
|
|
const busy = (why) => seatError(`session workspace ${workspace} is busy: ${why}`, "session-workspace-busy");
|
|
for (let attempt = 0; attempt < 2; attempt++) {
|
|
try {
|
|
write("wx");
|
|
// One release per lock: a second unlink could take a lock another host has written since.
|
|
let released = false;
|
|
return {
|
|
file,
|
|
update(fields) {
|
|
if (released) return;
|
|
held = { ...held, ...fields };
|
|
write("w");
|
|
},
|
|
release() {
|
|
if (released) return;
|
|
released = true;
|
|
try {
|
|
unlinkSync(file);
|
|
} catch (e) {
|
|
if (e.code !== "ENOENT") throw e;
|
|
}
|
|
},
|
|
};
|
|
} catch (e) {
|
|
if (e.code !== "EEXIST") throw e;
|
|
}
|
|
let raw;
|
|
try {
|
|
raw = readFileSync(file, "utf8");
|
|
} catch (e) {
|
|
if (e.code === "ENOENT") continue;
|
|
throw e;
|
|
}
|
|
let other = null;
|
|
try {
|
|
other = JSON.parse(raw);
|
|
} catch {}
|
|
// An unreadable lock may be one being written, so it counts as held.
|
|
if (!other || typeof other !== "object") throw busy(`${file} is unreadable`);
|
|
if (lockAlive(other.hostPid, other.hostStartTime)) throw busy(`host pid ${other.hostPid} holds it`);
|
|
if (lockAlive(other.runPid, other.runStartTime)) throw busy(`run pid ${other.runPid} holds it`);
|
|
// Stale. Move it aside; if what moved isn't what was judged stale, another
|
|
// host took it over in between, so it goes back and this start refuses.
|
|
const aside = `${file}.stale-${process.pid}-${randomBytes(4).toString("hex")}`;
|
|
try {
|
|
renameSync(file, aside);
|
|
} catch (e) {
|
|
if (e.code === "ENOENT") continue;
|
|
throw e;
|
|
}
|
|
if (readFileSync(aside, "utf8") !== raw) {
|
|
try {
|
|
linkSync(aside, file);
|
|
} catch {}
|
|
unlinkSync(aside);
|
|
throw busy(`another host took ${file} over`);
|
|
}
|
|
unlinkSync(aside);
|
|
}
|
|
throw busy(`${file} could not be taken`);
|
|
}
|
|
|
|
// The session's environment is an allowlist: nothing else from the host's
|
|
// environment passes, so a founder credential variable (GITEA_TOKEN,
|
|
// GH_TOKEN, SSH_AUTH_SOCK, ...) never reaches a session (REQ-CRED-2).
|
|
// Provider variables pass because the harness needs them to reach a model.
|
|
// MOSAIC_CLAUDE_BIN, the host's pinned Claude Code binary, is a path. HOME
|
|
// passes to bwrap only; inside, HOME is the run's own home/.
|
|
export const ENV_ALLOW = Object.freeze([
|
|
"HOME", "USER", "LOGNAME", "LANG", "LC_ALL", "TZ", "TERM",
|
|
"ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL", "CLAUDE_CODE_OAUTH_TOKEN",
|
|
"OPENAI_API_KEY", "OPENROUTER_API_KEY", "ZAI_API_KEY",
|
|
"MOSAIC_CLAUDE_BIN",
|
|
]);
|
|
|
|
// The ways a Claude Code session can log in, each a set of variables that
|
|
// must all be set; ENV_ALLOW passes them on. The bus unit loads them
|
|
// (packages/cli/README.md, "Unit"). The session gets nothing from ~/.claude,
|
|
// which the sandbox doesn't show.
|
|
export const SESSION_CREDENTIALS = Object.freeze([["CLAUDE_CODE_OAUTH_TOKEN"], ["ANTHROPIC_API_KEY"], ["ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL"]].map((set) => Object.freeze(set)));
|
|
export const hasSessionCredential = (env) => SESSION_CREDENTIALS.some((set) => set.every((k) => Boolean(env[k])));
|
|
|
|
export function sessionEnv(env, run) {
|
|
const out = {};
|
|
for (const k of ENV_ALLOW) if (env[k] !== undefined) out[k] = env[k];
|
|
out.PATH = [join(REPO, "node_modules", ".bin"), env.PATH ?? "/usr/bin:/bin"].join(":");
|
|
out.MOSAIC_RUN_ID = run;
|
|
return out;
|
|
}
|
|
|
|
// A new run id and its directory. Ids are short because the run directory
|
|
// holds a Unix socket (tools.sock), and socket paths stop at 107 bytes.
|
|
export function newRun(dataRoot, business) {
|
|
const root = runsDir(dataRoot, business);
|
|
mkdirSync(root, { recursive: true, mode: 0o700 });
|
|
for (let i = 0; i < 5; i++) {
|
|
const run = `r${randomBytes(6).toString("hex")}`;
|
|
const runDir = join(root, run);
|
|
try {
|
|
mkdirSync(runDir, { mode: 0o700 });
|
|
} catch (e) {
|
|
if (e.code === "EEXIST") continue;
|
|
throw e;
|
|
}
|
|
if (Buffer.byteLength(join(runDir, "tools.sock")) > 107) throw new SeatError(`data root path too long for a socket: ${runDir}`, 2);
|
|
return { run, runDir };
|
|
}
|
|
throw new SeatError("could not pick a free run id", 1);
|
|
}
|
|
|
|
export function writeSessionFile(runDir, session) {
|
|
writeFileSync(join(runDir, "session.json"), `${JSON.stringify(session, null, 2)}\n`, { mode: 0o600, flag: "wx" });
|
|
}
|
|
|
|
export function appendLaunchLog(dataRoot, business, entry) {
|
|
const file = launchLogFile(dataRoot, business);
|
|
mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
|
|
appendFileSync(file, `${JSON.stringify({ at: new Date().toISOString(), ...entry })}\n`, { mode: 0o600 });
|
|
}
|
|
|
|
// Start the runner in its sandbox. stdin stays open for the capability line
|
|
// the host writes once the broker has bound the launch; stdout and stderr go
|
|
// to runner.log. paths: what sandbox.mjs's binds() takes besides the run
|
|
// directory (workspace, adapter, harnessMounts, brokerSocket, launchSocket,
|
|
// gitSocket, threadStore; readOnly for tests). business and role (the
|
|
// instance) give the session its git identity. `bwrap` is for the tests.
|
|
export function spawnSession({ runDir, env, paths, business, role, node = process.execPath, bwrap }) {
|
|
prepareRun(runDir, { threadStore: paths.threadStore ?? null });
|
|
const argv = sandboxArgv(binds({ ...paths, runDir, node }), runDir, [node, RUNNER, runDir], { business, role, bwrap });
|
|
const out = openSync(join(runDir, "runner.log"), "a", 0o600);
|
|
try {
|
|
return spawn(argv[0], argv.slice(1), { cwd: runDir, env, stdio: ["pipe", out, out], detached: true });
|
|
} finally {
|
|
closeSync(out);
|
|
}
|
|
}
|
|
|
|
// A runner's command line is `<node> <RUNNER> <run dir>`. Matching argv[1]
|
|
// rather than any argument skips bwrap's forked child before its exec, whose
|
|
// argv still names the runner.
|
|
export const isRunner = (pid) => (cmdlineOf(pid) ?? [])[1] === RUNNER;
|
|
|
|
// The runner's pid and start time as seen from here: the outer bwrap
|
|
// process's only child.
|
|
export async function runnerOf(child, { timeoutMs = 5000 } = {}) {
|
|
const deadline = Date.now() + timeoutMs;
|
|
while (Date.now() < deadline) {
|
|
if (child.exitCode !== null || child.signalCode !== null) break;
|
|
const pid = childrenOf(child.pid)[0];
|
|
const start = pid ? startTimeOf(pid) : null;
|
|
if (start && isRunner(pid)) return { pid, startTime: start };
|
|
await new Promise((r) => setTimeout(r, 20));
|
|
}
|
|
throw new SeatError(`runner for ${child.pid} did not start`, 1);
|
|
}
|
|
|
|
// The outer bwrap's exit as the runner's: bwrap exits 128 + n when the
|
|
// runner dies of signal n, and the runner's own codes are all below 128.
|
|
const SIGNALS = Object.fromEntries(Object.entries(constants.signals).map(([name, n]) => [n, name]));
|
|
export function sessionExit(code, signal) {
|
|
if (!signal && code > 128 && SIGNALS[code - 128]) return { code: null, signal: SIGNALS[code - 128] };
|
|
return { code, signal };
|
|
}
|
|
|
|
// The launch end reason the broker records for a runner's exit
|
|
// (packages/harness/README.md, "The runner").
|
|
const REASONS = { 0: "stopped", 2: "failed", 20: "founder-credentials", 21: "claim-refused", 22: "session-invalid", 23: "broker-unreachable" };
|
|
export function endReason(code, signal) {
|
|
if (signal) return "killed";
|
|
return REASONS[code] ?? "failed";
|
|
}
|
|
|
|
// The host's view of its running sessions, kept in memory and mirrored to
|
|
// sessions.json for `mosaic stop` and `mosaic launches list`.
|
|
// readOnly (row 163, a --no-launch host): sessions.json stays as an earlier host left it, so a
|
|
// later host still finds and ends those runs. add() refuses, and nothing writes the file.
|
|
export class Registry {
|
|
#dataRoot;
|
|
#sessions = [];
|
|
#readOnly;
|
|
constructor(dataRoot, { readOnly = false } = {}) {
|
|
this.#dataRoot = dataRoot;
|
|
this.#readOnly = readOnly;
|
|
this.#write();
|
|
}
|
|
get sessions() {
|
|
return this.#sessions.map((s) => ({ ...s }));
|
|
}
|
|
add(entry) {
|
|
if (this.#readOnly) throw new SeatError("this host keeps no sessions (--no-launch)", 2);
|
|
this.#sessions.push({ ...entry });
|
|
this.#write();
|
|
}
|
|
remove(business, run) {
|
|
this.#sessions = this.#sessions.filter((s) => !(s.business === business && s.run === run));
|
|
this.#write();
|
|
}
|
|
count(business, provider, model = undefined) {
|
|
return this.#sessions.filter((s) => s.business === business && s.provider === provider && (model === undefined || s.model === model)).length;
|
|
}
|
|
// A thread instance runs once per thread session (row 121, row 269), so
|
|
// `thread` and `session` are part of the key; null is an entry without one.
|
|
running(business, instance, thread = null, session = null) {
|
|
return this.#sessions.find((s) => s.business === business && s.instance === instance && (s.thread ?? null) === thread && (s.session ?? null) === session) ?? null;
|
|
}
|
|
#write() {
|
|
if (this.#readOnly) return;
|
|
const file = sessionsFile(this.#dataRoot);
|
|
mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
|
|
const tmp = `${file}.${process.pid}.tmp`;
|
|
writeFileSync(tmp, `${JSON.stringify({ sessionsVersion: SESSIONS_VERSION, sessions: this.#sessions }, null, 2)}\n`, { mode: 0o600 });
|
|
renameSync(tmp, file);
|
|
}
|
|
}
|
|
|
|
// sessions.json as `mosaic stop` sees it. `live` is true only when the
|
|
// runner still runs with the recorded start time.
|
|
export function readSessions(dataRoot) {
|
|
const file = sessionsFile(dataRoot);
|
|
if (!existsSync(file)) return [];
|
|
let doc;
|
|
try {
|
|
doc = JSON.parse(readFileSync(file, "utf8"));
|
|
} catch {
|
|
throw new SeatError(`sessions file is unreadable: ${file}`, 2);
|
|
}
|
|
if (!SESSIONS_READ.includes(doc?.sessionsVersion) || !Array.isArray(doc.sessions)) throw new SeatError(`sessions file is malformed: ${file}`, 2);
|
|
return doc.sessions.map((s) => ({ ...s, live: startTimeOf(s.runnerPid) === s.runnerStartTime }));
|
|
}
|
|
|
|
// `mosaic stop <run>`: SIGTERM to the run's runner, after checking that the
|
|
// pid still has the recorded start time and runs the runner. Same-UID
|
|
// process control, not an authority check. The runner releases its role
|
|
// and the host records the end.
|
|
export async function stopSession(dataRoot, run, { timeoutMs = 30000 } = {}) {
|
|
const hits = readSessions(dataRoot).filter((s) => s.run === run);
|
|
if (hits.length === 0) throw new SeatError(`no running session has run id ${run}; see mosaic launches list`, 2);
|
|
const s = hits[0];
|
|
if (!s.live) return { stopped: false, reason: `run ${run} is not running (stale entry)` };
|
|
if (!isRunner(s.runnerPid)) throw new SeatError(`pid ${s.runnerPid} is not a session runner; refusing to signal it`, 2);
|
|
// Sent again every second: a runner that is still starting has no handler
|
|
// yet, and as pid 1 of its namespace it never sees a signal sent before then.
|
|
const deadline = Date.now() + timeoutMs;
|
|
let next = 0;
|
|
while (Date.now() < deadline) {
|
|
if (startTimeOf(s.runnerPid) !== s.runnerStartTime) return { stopped: true, business: s.business, instance: s.instance, run };
|
|
if (Date.now() >= next) {
|
|
try {
|
|
process.kill(s.runnerPid, "SIGTERM");
|
|
} catch {}
|
|
next = Date.now() + 1000;
|
|
}
|
|
await new Promise((r) => setTimeout(r, 100));
|
|
}
|
|
throw new SeatError(`run ${run} did not stop within ${Math.round(timeoutMs / 1000)} s`, 1);
|
|
}
|