@credibledata/cred-cli 0.0.103 → 0.0.105

package/dist/setup-core/supervisor.js

@@ -0,0 +1,879 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOG_DRAIN_WAIT_MS = exports.TOKEN_CHECK_INTERVAL_MS = exports.SESSION_PID_FILE = exports.RELOAD_TOOL = void 0;
+exports.npxLauncher = npxLauncher;
+exports.publisherLogPath = publisherLogPath;
+exports.isShownLine = isShownLine;
+exports.startPublisher = startPublisher;
+exports.startTokenLoop = startTokenLoop;
+exports.toolCallFailure = toolCallFailure;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const host_1 = require("./host");
+const publisherconfig_1 = require("./publisherconfig");
+const writefile_1 = require("./writefile");
+const readylines_1 = require("./readylines");
+const refresh_1 = require("./refresh");
+/**
+ * The MCP tool that reloads a package. Publisher renamed its tools to bare
+ * names in 0.2.x (`malloy_reloadPackage` → `reload_package`), and a renewal
+ * that calls a tool the server does not have fails silently: the token is
+ * rewritten on disk and the running server never learns of it. Pinned here,
+ * next to the publisher version it has to match.
+ */
+exports.RELOAD_TOOL = "reload_package";
+/**
+ * Running and babysitting the local Publisher.
+ *
+ * This is what both `cred init`'s last step and `cred dev` hand off to — one
+ * supervisor, so re-entering a session tomorrow is the same code path as
+ * starting one today.
+ *
+ * Three jobs, and the second is the one that is easy to get wrong:
+ *
+ *  1. Spawn the server with the config and ports it was given.
+ *  2. Decide whether it actually came up. Both ports bind and both "listening
+ *     at" lines print even when every configured environment failed to load, so
+ *     "the process is alive" is not readiness. The `PUBLISHER_READY` counts are.
+ *  3. Keep the warehouse token alive. A `publisher` connection's token is a
+ *     static JWT in a config file and the server has no refresh hook yet, so
+ *     without this the session dies mid-use and surfaces as a confusing query
+ *     error. Deleted wholesale once the upstream `tokenCommand` hook lands.
+ */
+/**
+ * The file in the session directory that holds the running publisher's pid.
+ * Present only while a session runs, like the stamped config beside it; see
+ * `isOwnSessionRunning` in `flow.ts` for why both are checked.
+ */
+exports.SESSION_PID_FILE = "publisher.pid";
+/** How long to wait for a readiness verdict before giving up on the spawn. */
+const BOOT_TIMEOUT_MS = 120000;
+/** How often to check whether the warehouse token needs renewing. */
+exports.TOKEN_CHECK_INTERVAL_MS = 60000;
+/**
+ * How long one renewal call to the server may take. Shorter than the tick, so a
+ * wedged server fails the call and the next tick retries it — without a bound,
+ * fetch waits out undici's five-minute default.
+ */
+const RELOAD_TIMEOUT_MS = 30000;
+/**
+ * How long a SIGTERM has to work before we stop asking and use SIGKILL.
+ *
+ * A publisher wedged mid-compile does not service signals, and SIGTERM alone
+ * left `waitUntilStopped` blocked on a child that was never going to exit — a
+ * second Ctrl-C only sent another SIGTERM, so the way out was killing the CLI
+ * from another tab, which is exactly the path that skips the config cleanup and
+ * leaves a token on disk. Escalating is what makes the cleanup reachable.
+ *
+ * Five seconds because the graceful path is worth waiting for: it lets the
+ * server close its DuckDB handles rather than leaving `publisher_data/` for the
+ * next run to recover.
+ */
+const SIGKILL_AFTER_MS = 5000;
+/**
+ * How long a failed boot waits for the child to close and the log file to be
+ * written out before it throws. The caller exits the process as soon as this
+ * throws, and the failure message sends people to the log. Bounded, so a
+ * child that ignores SIGTERM cannot hold the CLI open.
+ */
+exports.LOG_DRAIN_WAIT_MS = 2000;
+/** Windows has neither process groups nor POSIX signals. */
+const SUPPORTS_PROCESS_GROUPS = process.platform !== "win32";
+/**
+ * Signal the child and everything it launched.
+ *
+ * `npx` launches the server as a further child, so signalling the `npx` pid can
+ * leave the server running and holding both ports. Negating the pid targets the
+ * process group instead, which the spawn put the whole tree into. Falls back to
+ * the plain kill where there are no process groups, or if the group is already
+ * gone (ESRCH) — a race we can only lose harmlessly.
+ */
+function killTree(child, signal) {
+    if (SUPPORTS_PROCESS_GROUPS && child.pid) {
+        try {
+            process.kill(-child.pid, signal);
+            return;
+        }
+        catch (_a) {
+            // Group already reaped, or never created. Fall through.
+        }
+    }
+    child.kill(signal);
+}
+/**
+ * How to run `npx` without a shell.
+ *
+ * On Windows `npx` is `npx.cmd`, which a shell-less `spawn` cannot launch
+ * (ENOENT), and Node refuses to spawn a `.cmd` without a shell at all since the
+ * CVE-2024-27980 fix. A shell would re-parse the arguments, including paths
+ * with spaces in them. So on Windows this runs npx's own script with the node
+ * binary that is running us, from where the Node installer puts it.
+ */
+function npxLauncher(platform = process.platform, execPath = process.execPath, exists = fs_1.default.existsSync) {
+    if (platform !== "win32")
+        return { command: "npx", args: [] };
+    const script = path_1.default.join(path_1.default.dirname(execPath), "node_modules", "npm", "bin", "npx-cli.js");
+    if (!exists(script)) {
+        throw new host_1.SetupError(`Could not find npx next to ${execPath} (looked for ${script}).`, "install Node.js with npm from nodejs.org, or run cred from a Node that has npm beside it.");
+    }
+    return { command: execPath, args: [script] };
+}
+/** The escalation timer per child, so a repeated stop does not stack them. */
+const pendingKill = new WeakMap();
+/**
+ * Ask the tree to stop, and make sure it does.
+ *
+ * SIGTERM first, so a healthy server shuts down cleanly; SIGKILL after
+ * {@link SIGKILL_AFTER_MS} if it is still there. The timer is `unref`'d and
+ * cleared on exit, so a server that goes straight away leaves nothing holding
+ * the event loop open — the escalation must not be the reason the CLI lingers
+ * for five seconds on every ordinary Ctrl-C.
+ *
+ * Idempotent: a second Ctrl-C re-sends SIGTERM but does not stack a second
+ * timer, because the first one is already counting and a second would just fire
+ * later against a pid that is gone.
+ */
+function stopTree(child, host) {
+    var _a;
+    killTree(child, "SIGTERM");
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    if (pendingKill.has(child))
+        return;
+    const timer = setTimeout(() => {
+        pendingKill.delete(child);
+        if (child.exitCode !== null || child.signalCode !== null)
+            return;
+        host.log("warn", `The publisher did not stop within ${SIGKILL_AFTER_MS / 1000}s, so it was killed. If this repeats, the session directory may hold a stale publisher_data/.`);
+        killTree(child, "SIGKILL");
+    }, SIGKILL_AFTER_MS);
+    (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
+    pendingKill.set(child, timer);
+    child.once("exit", () => {
+        clearTimeout(timer);
+        pendingKill.delete(child);
+    });
+}
+/**
+ * Where a session's full server output goes: the directory's own `.credible/`,
+ * which setup keeps out of commits and `cred publish` never uploads. Truncated
+ * at each start, so it holds one session.
+ */
+function publisherLogPath(directory) {
+    return path_1.default.join(directory, ".credible", "publisher.log");
+}
+// The level winston's `simple` format puts first, after any colour codes.
+// eslint-disable-next-line no-control-regex
+const ANSI = /\x1b\[[0-9;]*m/g;
+/**
+ * Whether a line of the server's output is shown in the terminal by default.
+ *
+ * The full boot log read as alarming and was mostly noise: the server rebuilds
+ * its throwaway local store each start (`--init`), logging "dropping and
+ * recreating all tables" and a line per dropped table, and it warns about a
+ * memory setting that only matters in a container. What a person at this
+ * terminal needs is what goes wrong, so:
+ *
+ * - The server's `error:` lines. A failed watch-mode recompile is one of these
+ *   (`logger.error("Watch: failed to recompile …")` in the Publisher's
+ *   `watch-mode.controller.ts`), and it is the reason this terminal exists.
+ * - The one `info:` line that says a watch-mode recompile worked
+ *   (`Watch: recompiled package …`). Without it the last thing on screen after
+ *   a fixed model is still the error, and nothing says the error is gone.
+ * - Anything else on stderr, which is where the server writes
+ *   `PUBLISHER_INIT_FAILED`, a model's compile error with its caret, and a
+ *   crash's message. Except npm's own notices, the `PUBLISHER_READY` line, and
+ *   stack frames.
+ *
+ * Every other `warn:` and `info:` line is in the log file only.
+ *
+ * The same two rules apply to the server's JSON lines. It logs JSON instead of
+ * the text format when `OTEL_EXPORTER_OTLP_ENDPOINT` is set (`logger.ts` in the
+ * Publisher), and a user's environment reaches the child.
+ */
+function isShownLine(line, stream) {
+    const plain = line.replace(ANSI, "").trim();
+    if (!plain)
+        return false;
+    if (/^error\b/i.test(plain))
+        return true;
+    if (/^info\b.*\bWatch: recompiled package\b/i.test(plain))
+        return true;
+    const entry = jsonLogEntry(plain);
+    if ((entry === null || entry === void 0 ? void 0 : entry.level) === "error")
+        return true;
+    if ((entry === null || entry === void 0 ? void 0 : entry.level) === "info" &&
+        /\bWatch: recompiled package\b/.test(entry.message)) {
+        return true;
+    }
+    if (stream !== "stderr")
+        return false;
+    // npm's notices are about the launcher; `PUBLISHER_READY` is a machine line
+    // that `cred` answers with its own "serving" line; and a stack's frames
+    // follow the message that says what went wrong, which is shown.
+    return !/^(npm (warn|notice)\b|PUBLISHER_READY\b|at )/i.test(plain);
+}
+/**
+ * The level and message of a line in winston's JSON format, or undefined for
+ * any other line. Its keys are sorted, so `level` is not first.
+ */
+function jsonLogEntry(plain) {
+    if (!plain.startsWith("{"))
+        return undefined;
+    try {
+        const parsed = JSON.parse(plain);
+        if (!parsed || typeof parsed !== "object")
+            return undefined;
+        const { level, message } = parsed;
+        if (typeof level !== "string")
+            return undefined;
+        return {
+            level: level.toLowerCase(),
+            message: typeof message === "string" ? message : "",
+        };
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+/** Open the session's log file, or undefined when it cannot be written. */
+function openLogFile(logPath) {
+    try {
+        fs_1.default.mkdirSync(path_1.default.dirname(logPath), { recursive: true });
+        // `openSync` first, so a failure is thrown here rather than emitted later
+        // on the stream, where nothing would see it.
+        const fd = fs_1.default.openSync(logPath, "w");
+        const stream = fs_1.default.createWriteStream("", { fd });
+        // A later write error (a full disk) must not crash the session: the log
+        // is a copy, and the terminal still shows the errors.
+        stream.on("error", () => undefined);
+        return stream;
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+/**
+ * Write the config with a live access token in it, ready for the server to read.
+ *
+ * This file is a credential for as long as a session runs. Two things follow,
+ * and both are load-bearing rather than tidiness: it is written 0600, inside the
+ * 0700 session directory that `flow.ts` chose for exactly this reason, so no
+ * other account on the machine can read the token; and it is removed by
+ * {@link discardConfig} when the session ends, so a token does not outlive the
+ * process that needed it.
+ */
+function writeStampedConfig(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const outcome = yield (0, refresh_1.ensureFreshTokens)(options.credStore);
+        if (outcome.status === "logged-out") {
+            return { status: "failed", reason: outcome.reason };
+        }
+        let warning;
+        if (outcome.status === "offline") {
+            // Carrying on is only true while the token on disk still works. Once it
+            // has expired, saying so while every query 401s is the wrong message, so
+            // it becomes a failure and the caller says to run `cred login`.
+            if (!options.credStore.isTokenValid().valid) {
+                return {
+                    status: "failed",
+                    reason: `${outcome.reason} The token on disk has expired.`,
+                };
+            }
+            warning = `${outcome.reason} Continuing with the token on disk.`;
+        }
+        if (outcome.status === "not-renewable") {
+            warning = outcome.reason;
+        }
+        const token = options.credStore.getApiAccessToken();
+        if (!token) {
+            return {
+                status: "failed",
+                reason: "No access token available. Run `cred login`.",
+            };
+        }
+        (0, writefile_1.writeFileAtomic)(options.configPath, `${JSON.stringify((0, publisherconfig_1.stampAccessToken)(options.config, token), null, 3)}\n`, { mode: 0o600 });
+        return { status: "ok", token, warning };
+    });
+}
+/**
+ * Remove the config once nothing needs it.
+ *
+ * Best-effort on purpose: failing to delete it must not turn a clean shutdown
+ * into an error, and the 0700 directory means an undeleted file is still not
+ * readable by anyone else. A `kill -9` skips this, which is the residual case
+ * the directory mode covers.
+ */
+function discardConfig(configPath) {
+    for (const file of [
+        configPath,
+        path_1.default.join(path_1.default.dirname(configPath), exports.SESSION_PID_FILE),
+    ]) {
+        try {
+            fs_1.default.unlinkSync(file);
+        }
+        catch (_a) {
+            // Already gone, or not ours to remove.
+        }
+    }
+}
+/**
+ * Start the publisher and wait for a readiness verdict.
+ *
+ * Resolves only once the server has reported itself ready AND that report says
+ * it is serving something. Anything else — an init failure, a premature exit, a
+ * timeout, a ready-but-empty server — throws with what the server said.
+ */
+function startPublisher(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        // Before the token is written, so a refusal leaves no credential behind.
+        const launcher = npxLauncher();
+        const stamped = yield writeStampedConfig(options);
+        if (stamped.status === "failed") {
+            throw new host_1.SetupError(stamped.reason);
+        }
+        if (stamped.warning)
+            options.host.log("warn", stamped.warning);
+        const logPath = publisherLogPath(options.directory);
+        const logFile = openLogFile(logPath);
+        // With no file to put it in, the output would be lost, so it all shows here.
+        const showAll = Boolean(options.showAllOutput) || !logFile;
+        const where = logFile
+            ? path_1.default.relative(process.cwd(), logPath) || logPath
+            : undefined;
+        options.host.log("info", `Starting the local Publisher (${options.publisherVersion}). The first run downloads it, which takes about 30 seconds.${where && !options.showAllOutput
+            ? ` Its errors show here; its full output is in ${where} (--debug shows it all here).`
+            : ""}`);
+        /** Where to read the rest, for a failure message. */
+        const outputIs = showAll
+            ? "Its output is above."
+            : `Its output is in ${where}.`;
+        const child = (0, child_process_1.spawn)(launcher.command, [
+            ...launcher.args,
+            "-y",
+            `@malloy-publisher/server@${options.publisherVersion}`,
+            "--server_root",
+            options.serverRoot,
+            // Rebuild the server's store from the config this run just wrote.
+            // Without it the server trusts its `publisher.db` from the last session
+            // over the config, so every session after the first in a directory
+            // served that first session's long-expired warehouse token, and ignored
+            // a changed environment or connection list.
+            "--init",
+            // Absolute, so it does not have to resolve against server_root.
+            "--config",
+            path_1.default.resolve(options.configPath),
+            "--host",
+            "127.0.0.1",
+            "--port",
+            String(options.uiPort),
+            "--mcp_port",
+            String(options.mcpPort),
+            "--watch-env",
+            options.watchEnvironment,
+        ], {
+            cwd: options.serverRoot,
+            env: Object.assign(Object.assign(Object.assign({}, process.env), { 
+                // Set only for this child. Never documented as something a user
+                // exports: in a hosted deployment this flag opens an SSRF surface,
+                // and it is default-deny for that reason.
+                PUBLISHER_ALLOW_PROXY_CONNECTIONS: "true", 
+                // This terminal exists to show one thing: a failed recompile, which
+                // watch mode writes to stdout and nowhere else. The server's
+                // defaults bury that. It logs at `debug` unless told otherwise, and
+                // logs every HTTP response — so opening the UI emits a line per
+                // asset, and the compile error a user is looking for scrolls away
+                // behind `GET /assets/index-*.js 200`.
+                //
+                // Both are the server's own knobs (`getLogLevel`,
+                // `DISABLE_RESPONSE_LOGGING` in its `server.mjs`), which is why this
+                // is set here rather than filtered out of the stream: matching its
+                // log lines with our own patterns would be a second, guessed copy of
+                // a decision it already exposes. A user who wants the firehose can
+                // still set LOG_LEVEL themselves — `...process.env` comes first, so
+                // their value wins.
+                LOG_LEVEL: (_a = process.env.LOG_LEVEL) !== null && _a !== void 0 ? _a : "info", DISABLE_RESPONSE_LOGGING: (_b = process.env.DISABLE_RESPONSE_LOGGING) !== null && _b !== void 0 ? _b : "true" }), (process.env.npm_config_loglevel === undefined &&
+                process.env.NPM_CONFIG_LOGLEVEL === undefined
+                ? { npm_config_loglevel: "error" }
+                : {})),
+            // `npx` is a launcher: the server runs as its child, not as `npx`
+            // itself. Signalling `npx` alone is not guaranteed to reach the
+            // server, and an orphaned server keeps both ports — which surfaces
+            // later as the next `cred dev` failing to allocate, blaming "whatever
+            // is holding ports", when the culprit is the previous run. Its own
+            // process group makes the whole tree signalable in one call. Not on
+            // Windows, which has no process groups and no POSIX signals.
+            detached: SUPPORTS_PROCESS_GROUPS,
+        });
+        // Beside the config, so "this directory's session is running" can ask
+        // whether this process is alive rather than trusting a file that a
+        // `kill -9` or a reboot leaves behind.
+        if (child.pid) {
+            (0, writefile_1.writeFileAtomic)(path_1.default.join(path_1.default.dirname(options.configPath), exports.SESSION_PID_FILE), `${child.pid}\n`);
+        }
+        // From here until the child exits, a Ctrl-C has to stop the child. It runs
+        // in its own process group, so the terminal's SIGINT reaches only us, and
+        // the host's default — exit — would leave it serving on both ports with the
+        // token file on disk. Subscribed now rather than after readiness because
+        // the boot wait can be two minutes, and that is when people press Ctrl-C.
+        let interrupted = false;
+        const unsubscribeInterrupt = (_e = (_d = (_c = options.host).onInterrupt) === null || _d === void 0 ? void 0 : _d.call(_c, () => {
+            interrupted = true;
+            stopTree(child, options.host);
+        })) !== null && _e !== void 0 ? _e : (() => undefined);
+        child.once("exit", () => unsubscribeInterrupt());
+        // Bound ports come from the listening lines; readiness comes from the
+        // PUBLISHER_READY line. We need both: the first for the URLs, the second to
+        // know whether the server is worth pointing anyone at.
+        let boundMcpPort = options.mcpPort;
+        let boundUiPort = options.uiPort;
+        // What the server says it bound, not what we asked for. They differ when a
+        // flag does not land — a mistyped `--host` falls back to a wildcard bind —
+        // and the whole point of reading the line is to dial what is actually there.
+        let boundMcpHost = "127.0.0.1";
+        let boundUiHost = "127.0.0.1";
+        // Subscribed now so the event cannot be missed. The log file is ended on
+        // the child's `close` (below), and has reached the disk once it closes.
+        const logClosed = new Promise((resolve) => {
+            if (logFile)
+                logFile.once("close", () => resolve());
+            else
+                child.once("close", () => resolve());
+        });
+        /**
+         * Wait for the log to reach the disk, but not forever: a grandchild that
+         * outlives the server can hold its stdio open, and then `close` never comes.
+         */
+        const logDrained = () => __awaiter(this, void 0, void 0, function* () {
+            let drainTimer;
+            yield Promise.race([
+                logClosed,
+                new Promise((resolve) => {
+                    drainTimer = setTimeout(resolve, exports.LOG_DRAIN_WAIT_MS);
+                }),
+            ]);
+            clearTimeout(drainTimer);
+        });
+        const verdict = yield new Promise((resolve) => {
+            var _a, _b;
+            let settled = false;
+            const finish = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                resolve(result);
+            };
+            const timer = setTimeout(() => finish({
+                status: "failed",
+                reason: `the publisher did not report readiness within ${BOOT_TIMEOUT_MS / 1000}s. ${outputIs}`,
+            }), BOOT_TIMEOUT_MS);
+            /** Returns true once a line has settled the verdict. */
+            const readLine = (line) => {
+                const endpoint = (0, readylines_1.parseReadyLine)(line);
+                if ((endpoint === null || endpoint === void 0 ? void 0 : endpoint.which) === "mcp") {
+                    boundMcpPort = endpoint.port;
+                    boundMcpHost = endpoint.host;
+                }
+                if ((endpoint === null || endpoint === void 0 ? void 0 : endpoint.which) === "ui") {
+                    boundUiPort = endpoint.port;
+                    boundUiHost = endpoint.host;
+                }
+                const failure = (0, readylines_1.parseInitFailedLine)(line);
+                if (failure) {
+                    finish({ status: "failed", reason: failure });
+                    return true;
+                }
+                const readiness = (0, readylines_1.parseReadinessLine)(line);
+                if (readiness) {
+                    const verdict = (0, readylines_1.readinessVerdict)(readiness);
+                    finish(verdict.kind === "fatal"
+                        ? { status: "failed", reason: verdict.reason }
+                        : verdict.kind === "degraded"
+                            ? { status: "degraded", reason: verdict.reason }
+                            : { status: "ok" });
+                    return true;
+                }
+                return false;
+            };
+            // One buffer per stream, not one shared by both. stdout and stderr are
+            // independent and unordered, so a shared splice point lets an stderr
+            // write land *inside* a stdout line that arrived in two chunks:
+            // `PUBLISHER_READY ... envir` + `warn: ...` + `onments=1 ...` splits into
+            // two lines, the first of which still carries the marker but has lost the
+            // counts. `parseReadinessLine` then returns undefined, the verdict is
+            // never reached, and a healthy server dies on the boot timeout — as an
+            // intermittent failure nobody can reproduce on demand. The publisher does
+            // write to stderr in this window: `PUBLISHER_INIT_FAILED` goes there, and
+            // LOG_LEVEL=info keeps warnings flowing.
+            const makeConsumer = (stream) => {
+                let buffer = "";
+                return (chunk) => {
+                    var _a;
+                    const text = chunk.toString();
+                    logFile === null || logFile === void 0 ? void 0 : logFile.write(text);
+                    // Watch mode swallows failed recompiles to stdout by design, so
+                    // this terminal is the only place a human sees them. That is the
+                    // whole reason the session runs in the foreground. Verbatim,
+                    // because the text already has the server's own level and colours
+                    // on it — see `Host.write`.
+                    if (showAll)
+                        options.host.write(text);
+                    buffer += text;
+                    const lines = buffer.split("\n");
+                    // Keep a possibly-partial trailing line for the next chunk, so a
+                    // readiness line split across chunks is not read as truncated.
+                    buffer = (_a = lines.pop()) !== null && _a !== void 0 ? _a : "";
+                    for (const line of lines) {
+                        // Before `readLine`, which can return early: the line that
+                        // settles the verdict may be the error a person needs to see.
+                        if (!showAll && isShownLine(line, stream)) {
+                            options.host.write(`${line}\n`);
+                        }
+                    }
+                    for (const line of lines) {
+                        if (readLine(line))
+                            return;
+                    }
+                };
+            };
+            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on("data", makeConsumer("stdout"));
+            (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on("data", makeConsumer("stderr"));
+            // On `close`, not `exit`: stdio can still deliver the last chunks after
+            // `exit`, and a crash on boot prints its stack as it dies.
+            child.once("close", () => logFile === null || logFile === void 0 ? void 0 : logFile.end());
+            child.on("error", (error) => finish({
+                status: "failed",
+                reason: `could not start the publisher: ${error.message}`,
+            }));
+            child.on("exit", (code) => finish({
+                status: "failed",
+                reason: `the publisher exited with code ${code} before reporting readiness. ${outputIs}`,
+            }));
+        });
+        if (verdict.status === "failed") {
+            stopTree(child, options.host);
+            discardConfig(options.configPath);
+            // The caller exits the process as soon as this throws, and the message
+            // sends people to the log, so let the log finish first.
+            yield logDrained();
+            if (interrupted) {
+                throw new host_1.SetupError("Stopped before the local Publisher was ready. It has been shut down.");
+            }
+            throw new host_1.SetupError(`The local Publisher did not come up: ${verdict.reason}`, "fix the reported problem and run `cred dev` again.");
+        }
+        // A model that does not compile is the state a session is most needed in, not
+        // a reason to refuse one. The server is up, its connections are live, watch
+        // mode is active and `compile_model` works over MCP — so the fix loop is
+        // available, and saving the file reloads it. What changes is that there is
+        // nothing to look at yet, so the browser stays shut.
+        const serving = verdict.status === "ok";
+        if (!serving) {
+            options.host.log("warn", `The publisher is running, but ${verdict.reason}. Fix the model and save — watch mode reloads it, and no restart is needed.`);
+        }
+        const uiUrl = `http://localhost:${boundUiPort}`;
+        // An IP literal rather than `localhost`, deliberately: an agent reads this
+        // out of `.mcp.json`, and `localhost` can resolve to `::1` on a host whose
+        // resolver prefers IPv6, where the server is not listening. `dialableHost`
+        // maps what the server actually bound — including a wildcard bind, which is
+        // not dialable — onto something that can be connected to. Bracketed because
+        // an IPv6 literal in a URL has to be.
+        const mcpUrl = `${dialableOrigin(boundMcpHost, boundMcpPort)}/mcp`;
+        const apiUrl = dialableOrigin(boundUiHost, boundUiPort);
+        // The URLs the server actually bound, not the ones we asked for: the
+        // renewal loop has to reach the same endpoints an agent does.
+        const stopTokenLoop = startTokenLoop(options, child, { mcpUrl, apiUrl }, stamped.token);
+        // Bound to the child's exit, not to `waitForExit` being called: the token
+        // must go when the server does, whether or not anyone is waiting on it.
+        // A caller that starts a session and drops it still leaves no credential
+        // behind.
+        //
+        // The same handler latches the exit code, because `waitForExit` subscribes
+        // only when the caller invokes it — and there is real time before that: the
+        // `openUrl` below awaits a full `exec()` of the OS browser command, which is
+        // the default path. A publisher that dies in that window fires its one
+        // `exit` event with nobody subscribed, so a promise created afterwards never
+        // settles. Nothing then holds the event loop (the child is reaped and the
+        // token-loop interval is `unref`'d), so the process ends with `exitCode`
+        // never set — reporting success, after printing that the publisher is
+        // serving. An agent shelling out and checking the status reads clean.
+        let exitedWith;
+        child.once("exit", (code) => {
+            exitedWith = code;
+            discardConfig(options.configPath);
+        });
+        if (options.openBrowser && serving) {
+            yield options.host.openUrl(uiUrl);
+        }
+        return {
+            uiUrl,
+            mcpUrl,
+            waitForExit: () => __awaiter(this, void 0, void 0, function* () {
+                // Already gone when `exitedWith` is set. The interval is then cleared
+                // by `startTokenLoop`'s own exit handler, so there is nothing to stop.
+                const code = exitedWith !== undefined
+                    ? exitedWith
+                    : yield new Promise((resolve) => {
+                        child.once("exit", (exitCode) => {
+                            stopTokenLoop();
+                            resolve(exitCode);
+                        });
+                    });
+                // `exit` comes before the last output is in the log file: stdio can
+                // still deliver after it, and the file is ended only on `close`.
+                yield logDrained();
+                return code;
+            }),
+            interrupted: () => interrupted,
+            stop: () => {
+                stopTokenLoop();
+                stopTree(child, options.host);
+            },
+        };
+    });
+}
+/** `http://host:port` for a host the server reported binding. */
+function dialableOrigin(boundHost, port) {
+    const host = (0, readylines_1.dialableHost)(boundHost);
+    return `http://${host.includes(":") ? `[${host}]` : host}:${port}`;
+}
+/**
+ * Keep the warehouse token fresh for as long as the session runs.
+ *
+ * The server reads `accessToken` out of its config only at boot, so renewing
+ * means rewriting the config (for the next boot) and updating each `publisher`
+ * connection on the running server, which swaps the live credential. A
+ * `reload_package` alone recompiles against the connections the server already
+ * holds, so it answered 200 and the old token stayed live. A failed update
+ * keeps the old connection serving, so a bad refresh degrades to a stale token
+ * rather than a dead server.
+ *
+ * The loop remembers the token it last handed the server (`applied`, starting
+ * with the one the boot wrote), and pushes whenever `~/.cred` holds a different
+ * one. The expiry on disk alone is not enough: another `cred dev`, a `cred`
+ * command or the VS Code extension can refresh `~/.cred` first, and then the
+ * token on disk has hours left while this server still holds the old one. The
+ * same rule retries a push that failed, because `applied` only moves once the
+ * server has taken the token.
+ *
+ * Replaced entirely by the upstream `tokenCommand` hook when it lands: that
+ * makes the server fetch its own token via `cred token`, and this whole loop,
+ * plus the config rewriting, goes away.
+ */
+function startTokenLoop(options, child, endpoints, bootToken) {
+    var _a;
+    // One renewal at a time. The expiry check below reads the token on disk,
+    // which does not change until a renewal finishes writing it — so a renewal
+    // slower than the tick interval would let the next tick pass the same check
+    // and start a second one. Two concurrent redemptions of one refresh token is
+    // the worst possible race here: with Auth0 rotation on, the loser gets
+    // `invalid_grant`, which is indistinguishable from a genuinely dead token
+    // and takes the whole credential store with it (see `refresh.ts`). There is
+    // no timeout that makes that safe, so the guard is a flag, not a deadline.
+    let renewing = false;
+    let applied = bootToken;
+    // A push that failed for this token. Retried every tick, but warned about
+    // once: a line a minute would bury the compile errors this terminal is for.
+    let failedToApply;
+    // The last warning printed, so an Auth0 outage says so once rather than on
+    // every tick until it ends.
+    let lastWarning;
+    const warnOnce = (message) => {
+        if (message === lastWarning)
+            return;
+        lastWarning = message;
+        options.host.log("warn", message);
+    };
+    const timer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+        if (renewing)
+            return;
+        renewing = true;
+        try {
+            const remaining = options.credStore.secondsUntilExpiry();
+            const renewDue = remaining !== undefined && remaining <= refresh_1.REFRESH_SKEW_SECONDS;
+            if (!renewDue && options.credStore.getApiAccessToken() === applied) {
+                return;
+            }
+            const stamped = yield writeStampedConfig(options);
+            if (stamped.status === "failed") {
+                warnOnce(`Could not renew the warehouse token: ${stamped.reason} Queries may start failing until you run \`cred login\`.`);
+                return;
+            }
+            if (stamped.warning)
+                warnOnce(stamped.warning);
+            // Offline with the token still valid: nothing new to hand over, so
+            // no request to the server and no "Renewed" line.
+            if (stamped.token === applied)
+                return;
+            try {
+                yield applyToken(options, endpoints, stamped.token);
+            }
+            catch (error) {
+                if (failedToApply !== stamped.token) {
+                    failedToApply = stamped.token;
+                    options.host.log("warn", `Renewed the token but could not hand it to the publisher: ${error instanceof Error ? error.message : String(error)}. Retrying every minute.`);
+                }
+                return;
+            }
+            const retried = failedToApply === stamped.token;
+            applied = stamped.token;
+            failedToApply = undefined;
+            lastWarning = undefined;
+            options.host.log("info", retried
+                ? "The publisher is using the renewed warehouse token."
+                : "Renewed the warehouse token.");
+        }
+        catch (error) {
+            // Nothing awaits this callback, so a throw here is an unhandled
+            // rejection, and the CLI's handler for those exits the process. That
+            // skipped the shutdown: the publisher kept running and its token file
+            // stayed on disk. A corrupt or unreadable `~/.cred` was enough. Skip
+            // the tick instead, like every other failure in this loop.
+            options.host.log("warn", `Could not check the warehouse token: ${error instanceof Error ? error.message : String(error)}. Trying again in a minute.`);
+        }
+        finally {
+            renewing = false;
+        }
+    }), exports.TOKEN_CHECK_INTERVAL_MS);
+    // `unref` below stops this holding the event loop open; the child does that.
+    (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
+    child.once("exit", () => clearInterval(timer));
+    return () => clearInterval(timer);
+}
+/**
+ * Put `token` into the running server's connections, then reload.
+ *
+ * The connection update (`PATCH /api/v0/environments/:env/connections/:name`)
+ * is what swaps the live credential. The reload after it recompiles each
+ * package, so none keeps a connection built from the old token.
+ */
+function applyToken(options, endpoints, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const stamped = (0, publisherconfig_1.stampAccessToken)(options.config, token);
+        for (const environment of stamped.environments) {
+            for (const connection of environment.connections) {
+                if (connection.type !== "publisher" ||
+                    !connection.publisherConnection) {
+                    continue;
+                }
+                const response = yield fetch(`${endpoints.apiUrl}/api/v0/environments/${encodeURIComponent(environment.name)}/connections/${encodeURIComponent(connection.name)}`, {
+                    signal: AbortSignal.timeout(RELOAD_TIMEOUT_MS),
+                    method: "PATCH",
+                    headers: { "Content-Type": "application/json" },
+                    // The whole sub-object: the server merges a patch one level deep.
+                    body: JSON.stringify({
+                        publisherConnection: connection.publisherConnection,
+                    }),
+                });
+                if (!response.ok) {
+                    throw new Error(`updating connection ${connection.name} returned HTTP ${response.status}`);
+                }
+            }
+        }
+        yield reloadPackages(options, endpoints.mcpUrl);
+    });
+}
+/**
+ * Ask the running server to recompile each package.
+ *
+ * Uses the MCP endpoint's `reload_package` ({@link RELOAD_TOOL}). It recompiles
+ * against the connections the server holds, so it does not pick up a token by
+ * itself; {@link applyToken} updates the connections first.
+ */
+function reloadPackages(options, mcpUrl) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const packageNames = options.config.environments.flatMap((environment) => environment.packages.map((pkg) => pkg.name));
+        for (const name of packageNames) {
+            // `mcpUrl`, not `options.mcpPort`: the requested port and host are not
+            // necessarily the ones the server bound (a flag that does not land falls
+            // back to a wildcard bind), and the caller already parsed the listening
+            // line to find out. Dialing the request instead meant a renewal on a
+            // relocated server failed its reload every hour and the session served a
+            // stale warehouse token until restart.
+            const response = yield fetch(mcpUrl, {
+                signal: AbortSignal.timeout(RELOAD_TIMEOUT_MS),
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "application/json, text/event-stream",
+                },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: 1,
+                    method: "tools/call",
+                    params: {
+                        name: exports.RELOAD_TOOL,
+                        arguments: {
+                            environmentName: options.watchEnvironment,
+                            packageName: name,
+                        },
+                    },
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`reload returned HTTP ${response.status}`);
+            }
+            // A tool failure is not an HTTP failure: MCP answers 200 with a JSON-RPC
+            // `error`, or a `result` flagged `isError`, and the reload has not
+            // happened. Read as success, the loop stopped retrying.
+            const failure = toolCallFailure((_a = response.headers.get("content-type")) !== null && _a !== void 0 ? _a : "", yield response.text());
+            if (failure)
+                throw new Error(`reload of ${name} failed: ${failure}`);
+        }
+    });
+}
+/**
+ * Why a `tools/call` response says the call failed, or undefined if it did not.
+ *
+ * The MCP endpoint answers with plain JSON or with a server-sent-events stream
+ * (the request accepts both), so both are read. A body that is neither is
+ * reported as a failure too: a reload nobody can confirm is retried.
+ */
+function toolCallFailure(contentType, body) {
+    var _a, _b, _c, _d;
+    const messages = [];
+    try {
+        if (contentType.includes("text/event-stream")) {
+            for (const line of body.split("\n")) {
+                // A blank `data:` is a keep-alive or priming event, not a reply.
+                // Parsed, it read as unreadable and the reload retried every tick.
+                const payload = line.startsWith("data:")
+                    ? line.slice("data:".length).trim()
+                    : "";
+                if (payload)
+                    messages.push(JSON.parse(payload));
+            }
+        }
+        else if (body.trim()) {
+            messages.push(JSON.parse(body));
+        }
+    }
+    catch (_e) {
+        return "the server sent a response that could not be read";
+    }
+    for (const message of messages) {
+        const { error, result } = (message !== null && message !== void 0 ? message : {});
+        if (error)
+            return (_a = error.message) !== null && _a !== void 0 ? _a : "the server returned an error";
+        if (result === null || result === void 0 ? void 0 : result.isError) {
+            return ((_d = (_c = (_b = result.content) === null || _b === void 0 ? void 0 : _b.find((part) => part.text)) === null || _c === void 0 ? void 0 : _c.text) !== null && _d !== void 0 ? _d : "the tool reported an error");
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=supervisor.js.map