Review "changes 8" fix round for org-redact6. - launcher: a harness module's throw names its system code or class, never its message; preflight, loader, bundle, checkout, sandbox and route text is relayed with host paths replaced (relay()). - claude-code and pi preflights name MOSAIC_CLAUDE_BIN and the repository's node_modules, never a path; persona and skill bundle errors and sandboxProblem name their file or the sandbox by label. - seat session: thread store, legacy store, overlap, busy lock and newRun refusals name the place under the data root. - discord: unknown keys, binding names and turn ids are described when not plain; approvals, journal and repository read errors name the file and code; git drops stderr lines that carry a host path and a spawn failure names its code only. - seat, control-board: registration fields and seen keys are described when not plain; invalid seat name and layout state the constraint. - organization: the registry names the config directory and registry file by label; --project is quoted only when it is a plain name; systemConfigProblem moves to its own module. - scripts/mosaic-config.mjs: the config by where it came from, the data root and its marker by role, keys and arguments only when plain, and error codes in place of raw messages. Exit codes unchanged. - webui sso-config: an unknown console key is named only when plain. Sentinel tests in each package's path-redaction-labels file fail on BASE; pins that quoted a path now assert the label and its absence.
446 lines
22 KiB
JavaScript
446 lines
22 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 { basename, dirname, join, relative, 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 "../../organization/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);
|
|
}
|
|
}
|
|
// A directory under the data root is named by its path relative to the data root, never
|
|
// its host path (#1873). Every segment below the root is a checked id or a fixed name.
|
|
const under = (dataRoot, p) => `under the data root, ${relative(dataRoot, p) || "the root itself"}`;
|
|
// Makes each directory in order, then checks it is ours, a real directory and private.
|
|
function privateDirs(what, dataRoot, dirs, code) {
|
|
for (const d of dirs) {
|
|
// A system error keeps its code and type; its message names the directory by label.
|
|
const quiet = (e) => Object.assign(e, { message: `${what}: cannot ${e.syscall ?? "use"} ${under(dataRoot, d)} (${e.code})` });
|
|
try {
|
|
mkdirSync(d, { mode: 0o700 });
|
|
} catch (e) {
|
|
if (e.code !== "EEXIST") throw quiet(e);
|
|
}
|
|
let st;
|
|
try {
|
|
st = lstatSync(d);
|
|
} catch (e) {
|
|
throw quiet(e);
|
|
}
|
|
if (st.isSymbolicLink() || !st.isDirectory() || st.uid !== process.getuid() || st.mode & 0o077) throw seatError(`${what}: ${under(dataRoot, 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", dataRoot, [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: ${under(dataRoot, 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", dataRoot, [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", dataRoot, [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: ${under(dataRoot, path)} overlaps the legacy workspace ${relative(dataRoot, 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: ${under(dataRoot, path)} overlaps a live workspace`, "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 });
|
|
// Named by its session id (the workspace's last segment, a checked id), never its path (#1873).
|
|
const busy = (why) => seatError(`session workspace ${basename(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("its lock 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 its lock over");
|
|
}
|
|
unlinkSync(aside);
|
|
}
|
|
throw busy("its lock 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])));
|
|
|
|
// Used again at the serialization boundary: provider credentials are transient.
|
|
export const isProviderVariable = (name) => name.startsWith("ANTHROPIC_")
|
|
|| ["CLAUDE_CODE_OAUTH_TOKEN", "OPENAI_API_KEY", "OPENROUTER_API_KEY", "ZAI_API_KEY"].includes(name);
|
|
|
|
export function sessionEnv(env, run, proxy = null) {
|
|
const out = {};
|
|
for (const k of ENV_ALLOW) if (env[k] !== undefined && !(proxy && isProviderVariable(k))) 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: run ${run}`, 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: bus-host/sessions.json under the data root", 2);
|
|
}
|
|
// #1873: named by its fixed place under the data root, never by host path.
|
|
if (!SESSIONS_READ.includes(doc?.sessionsVersion) || !Array.isArray(doc.sessions)) throw new SeatError("sessions file is malformed: bus-host/sessions.json under the data root", 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);
|
|
}
|