@credibledata/cred-cli 0.0.103 → 0.0.105

package/dist/setup-core/supervisor.spec.js

@@ -0,0 +1,833 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 });
+const chai_1 = require("chai");
+const child_process_1 = __importDefault(require("child_process"));
+const events_1 = require("events");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = require("path");
+const stream_1 = require("stream");
+const sinon_1 = __importDefault(require("sinon"));
+const credstore_1 = require("./credstore");
+const environments_1 = require("./environments");
+const refresh = __importStar(require("./refresh"));
+const supervisor_1 = require("./supervisor");
+const PROD = environments_1.auth0ConfigsByEnv.production;
+/** An access token with plenty of life left, so no renewal is attempted. */
+function liveToken() {
+    const part = (value) => Buffer.from(JSON.stringify(value)).toString("base64url");
+    return `${part({ alg: "HS256", typ: "JWT" })}.${part({
+        aud: PROD.audience,
+        exp: Math.floor(Date.now() / 1000) + 7200,
+    })}.signature`;
+}
+const READY = "PUBLISHER_READY url=http://127.0.0.1:4000 mcp=http://127.0.0.1:4040 environments=1 packages=1 load_errors=0\n";
+/** A stand-in for the spawned publisher: real streams, controllable exit. */
+class FakeChild extends events_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.stdout = new stream_1.PassThrough();
+        this.stderr = new stream_1.PassThrough();
+        this.pid = undefined;
+        /** Every signal sent, in order — the escalation ladder is the assertion. */
+        this.signals = [];
+        /** Node sets these on a real child once it is gone; `stopTree` reads them. */
+        this.exitCode = null;
+        this.signalCode = null;
+    }
+    kill(signal = "SIGTERM") {
+        this.signals.push(signal);
+        return true;
+    }
+    /**
+     * Exit the way a real child does: state first, then `exit`, then `close`
+     * once its stdio has drained, which can be after more output arrives.
+     */
+    exit(code, signal = null) {
+        this.exitCode = code;
+        this.signalCode = signal;
+        this.emit("exit", code);
+        setImmediate(() => this.emit("close", code, signal));
+    }
+}
+function hostRecording(onOpenUrl) {
+    const logs = [];
+    return {
+        logs,
+        select(_m, choices) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return choices[0].value;
+            });
+        },
+        selectMany() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return [];
+            });
+        },
+        confirm() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return true;
+            });
+        },
+        log(level, message) {
+            logs.push(`${level}: ${message}`);
+        },
+        write() { },
+        openUrl() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (onOpenUrl)
+                    yield onOpenUrl();
+            });
+        },
+    };
+}
+describe("startPublisher", () => {
+    let workDir;
+    let child;
+    beforeEach(() => {
+        workDir = fs_1.default.mkdtempSync((0, path_1.join)(os_1.default.tmpdir(), "supervisor-"));
+        child = new FakeChild();
+        sinon_1.default
+            .stub(child_process_1.default, "spawn")
+            .returns(child);
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+        fs_1.default.rmSync(workDir, { recursive: true, force: true });
+    });
+    function credStore() {
+        const configPath = (0, path_1.join)(workDir, ".cred");
+        fs_1.default.writeFileSync(configPath, JSON.stringify({
+            configPerEnvironment: {
+                production: { jwtAccessToken: liveToken(), refreshToken: "r" },
+            },
+            activeEnvironment: "production",
+        }));
+        return new credstore_1.ClientConfiguration(configPath);
+    }
+    function options(host, openBrowser = true) {
+        return {
+            directory: workDir,
+            serverRoot: workDir,
+            configPath: (0, path_1.join)(workDir, "publisher.config.json"),
+            config: { frozenConfig: false, environments: [] },
+            uiPort: 4000,
+            mcpPort: 4040,
+            watchEnvironment: "local",
+            publisherVersion: "0.0.248",
+            host,
+            credStore: credStore(),
+            openBrowser,
+        };
+    }
+    /** Let queued stream and promise callbacks run. */
+    const settle = () => new Promise((resolve) => setImmediate(resolve));
+    // The publisher's one `exit` event fires while `openUrl` is still awaiting —
+    // the real host awaits a full `exec()` of the OS browser command, so this is
+    // hundreds of ms on the default path. `waitForExit` subscribes only after
+    // that, so without latching the code its promise never settles: nothing is
+    // left holding the event loop, and the process ends with `exitCode` unset —
+    // reporting success after telling the user the publisher is serving.
+    /** Boot to the point where `startPublisher` has returned a session. */
+    function boot(host_1) {
+        return __awaiter(this, arguments, void 0, function* (host, openBrowser = false) {
+            const started = (0, supervisor_1.startPublisher)(options(host, openBrowser));
+            yield settle();
+            child.stdout.write(READY);
+            return started;
+        });
+    }
+    describe("what reaches the terminal", () => {
+        // What the Publisher (0.9.5) prints on a normal boot and on a bad save,
+        // in winston's `simple` format with its colours on.
+        const BOOT = [
+            "\x1b[32minfo\x1b[39m: Reinitializing database schema dropping and recreating all tables",
+            "\x1b[32minfo\x1b[39m: Dropped table: connections",
+            "\x1b[33mwarn\x1b[39m: PUBLISHER_DUCKDB_MEMORY_LIMIT is unset: … See docs/configuration.md.",
+        ].join("\n");
+        const RECOMPILE_FAILED = '\x1b[31merror\x1b[39m: Watch: failed to recompile package "bars" in environment "local" {"error":{}}';
+        function hostWriting() {
+            const host = hostRecording();
+            host.written = "";
+            host.write = (chunk) => {
+                host.written += chunk;
+            };
+            return host;
+        }
+        it("shows the server's errors, keeps the rest in the log file, and says where", () => __awaiter(void 0, void 0, void 0, function* () {
+            const host = hostWriting();
+            const started = (0, supervisor_1.startPublisher)(options(host));
+            yield settle();
+            child.stdout.write(`${BOOT}\n`);
+            child.stderr.write("npm warn deprecated inflight@1.0.6: leaks memory\n");
+            child.stdout.write(READY);
+            const running = yield started;
+            child.stdout.write(`${RECOMPILE_FAILED}\n`);
+            yield settle();
+            (0, chai_1.expect)(host.written).to.equal(`${RECOMPILE_FAILED}\n`);
+            (0, chai_1.expect)(host.logs.join("\n")).to.contain("The first run downloads it, which takes about 30 seconds.");
+            (0, chai_1.expect)(host.logs.join("\n")).to.contain("publisher.log");
+            child.exit(0);
+            yield running.waitForExit();
+            // No extra wait: `waitForExit` settles only once the log is on disk,
+            // even when the writes are still queued at `exit` on a slow disk.
+            const log = fs_1.default.readFileSync((0, supervisor_1.publisherLogPath)(workDir), "utf-8");
+            (0, chai_1.expect)(log).to.contain("Dropped table: connections");
+            (0, chai_1.expect)(log).to.contain("npm warn deprecated");
+            (0, chai_1.expect)(log).to.contain("failed to recompile");
+        }));
+        it("keeps output that arrives after exit in the log file", () => __awaiter(void 0, void 0, void 0, function* () {
+            const host = hostWriting();
+            const started = (0, supervisor_1.startPublisher)(options(host));
+            yield settle();
+            child.exit(1);
+            // A crash on boot: the stack reaches the pipe after `exit` has fired.
+            child.stderr.write("Error: boom\n    at main (server.js:1:1)\n");
+            yield (0, chai_1.expect)(started).to.be.rejectedWith("exited with code 1");
+            // Read as soon as the failure is thrown: the CLI exits right then.
+            const log = fs_1.default.readFileSync((0, supervisor_1.publisherLogPath)(workDir), "utf-8");
+            (0, chai_1.expect)(log).to.contain("Error: boom");
+            (0, chai_1.expect)(log).to.contain("at main (server.js:1:1)");
+        }));
+        it("streams everything with showAllOutput, as --debug asks", () => __awaiter(void 0, void 0, void 0, function* () {
+            const host = hostWriting();
+            const started = (0, supervisor_1.startPublisher)(Object.assign(Object.assign({}, options(host)), { showAllOutput: true }));
+            yield settle();
+            child.stdout.write(`${BOOT}\n`);
+            child.stdout.write(READY);
+            const running = yield started;
+            (0, chai_1.expect)(host.written).to.contain("Dropped table: connections");
+            child.exit(0);
+            yield running.waitForExit();
+        }));
+        it("quiets npm's own notices, unless the user set a level", () => __awaiter(void 0, void 0, void 0, function* () {
+            const running = yield boot(hostRecording());
+            const env = child_process_1.default.spawn
+                .firstCall.args[2].env;
+            (0, chai_1.expect)(env.npm_config_loglevel).to.equal("error");
+            child.exit(0);
+            yield running.waitForExit();
+        }));
+        it("isShownLine: errors and stderr, not info, warn or npm notices", () => {
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)(RECOMPILE_FAILED, "stdout")).to.equal(true);
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)("error: plain", "stdout")).to.equal(true);
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)("\x1b[32minfo\x1b[39m: Dropped table: x", "stdout")).to.equal(false);
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)("warn: something", "stdout")).to.equal(false);
+            // The one info line shown: a fixed model's recompile, so the error
+            // above it is visibly over. Other watch-mode info lines stay hidden.
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)('\x1b[32minfo\x1b[39m: Watch: recompiled package "bars" in environment "local"', "stdout")).to.equal(true);
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)("\x1b[32minfo\x1b[39m: Watch change: /tmp/x/bars/model.malloy", "stdout")).to.equal(false);
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)('PUBLISHER_INIT_FAILED error="bad config"', "stderr")).to.equal(true);
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)("line 1: 'nope_field' is not defined", "stderr")).to.equal(true);
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)("    at Object.<anonymous> (server.js:1:1)", "stderr")).to.equal(false);
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)(READY.trim(), "stderr")).to.equal(false);
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)("npm warn deprecated glob@7", "stderr")).to.equal(false);
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)("   ", "stderr")).to.equal(false);
+        });
+        // Winston's JSON format, which the Publisher switches to when
+        // OTEL_EXPORTER_OTLP_ENDPOINT is set. These lines are its real output
+        // for the same calls, keys sorted as it writes them.
+        it("isShownLine: the same rules for the server's JSON lines", () => {
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)('{"error":{},"level":"error","message":"Watch: failed to recompile package \\"bars\\" in environment \\"local\\"","timestamp":"2026-10-14T16:39:52.466Z"}', "stdout")).to.equal(true);
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)('{"level":"info","message":"Watch: recompiled package \\"bars\\" in environment \\"local\\"","timestamp":"2026-10-14T16:39:52.467Z"}', "stdout")).to.equal(true);
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)('{"level":"info","message":"Dropped table: connections","timestamp":"2026-10-14T16:39:52.467Z"}', "stdout")).to.equal(false);
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)('{"level":"warn","message":"PUBLISHER_DUCKDB_MEMORY_LIMIT is unset","timestamp":"2026-10-14T16:39:52.467Z"}', "stdout")).to.equal(false);
+            (0, chai_1.expect)((0, supervisor_1.isShownLine)('{"level": oops', "stdout")).to.equal(false);
+        });
+    });
+    // Without it the server trusts the last session's `publisher.db` over the
+    // config just written, so every session after the first served that
+    // session's expired token.
+    it("rebuilds the server's store from the config on every boot", () => __awaiter(void 0, void 0, void 0, function* () {
+        const running = yield boot(hostRecording());
+        const args = child_process_1.default.spawn.firstCall
+            .args[1];
+        (0, chai_1.expect)(args).to.include("--init");
+        child.exit(0);
+        yield running.waitForExit();
+    }));
+    // What `isOwnSessionRunning` checks alongside the config: a pid that is
+    // alive, so leftover files from a killed session do not read as running.
+    it("records the publisher's pid while it runs, and removes it on exit", () => __awaiter(void 0, void 0, void 0, function* () {
+        Object.defineProperty(child, "pid", { value: 424242 });
+        const running = yield boot(hostRecording());
+        const pidPath = (0, path_1.join)(workDir, supervisor_1.SESSION_PID_FILE);
+        (0, chai_1.expect)(fs_1.default.readFileSync(pidPath, "utf-8")).to.equal("424242\n");
+        child.exit(0);
+        yield running.waitForExit();
+        (0, chai_1.expect)(fs_1.default.existsSync(pidPath)).to.equal(false);
+    }));
+    it("still reports the exit code when the server dies during the browser launch", () => __awaiter(void 0, void 0, void 0, function* () {
+        const host = hostRecording(() => __awaiter(void 0, void 0, void 0, function* () {
+            child.exit(1);
+            yield settle();
+        }));
+        const running = yield boot(host, true);
+        (0, chai_1.expect)(yield running.waitForExit()).to.equal(1);
+    }));
+    it("still reports the exit code when the server dies before anyone waits", () => __awaiter(void 0, void 0, void 0, function* () {
+        const running = yield boot(hostRecording());
+        child.exit(3);
+        yield settle();
+        (0, chai_1.expect)(yield running.waitForExit()).to.equal(3);
+    }));
+    it("resolves normally for a server that exits while being waited on", () => __awaiter(void 0, void 0, void 0, function* () {
+        const running = yield boot(hostRecording());
+        const waiting = running.waitForExit();
+        child.exit(0);
+        (0, chai_1.expect)(yield waiting).to.equal(0);
+    }));
+    /** Exit without `close`: the server is gone, its stdio is still open. */
+    function exitWithoutClose(code) {
+        child.exitCode = code;
+        child.emit("exit", code);
+    }
+    it("waits for the log file to close before reporting the exit", () => __awaiter(void 0, void 0, void 0, function* () {
+        const running = yield boot(hostRecording());
+        let exited;
+        const waiting = running.waitForExit().then((code) => {
+            exited = code;
+            return code;
+        });
+        exitWithoutClose(0);
+        child.stdout.write("info: shut down\n");
+        yield settle();
+        yield settle();
+        (0, chai_1.expect)(exited).to.equal(undefined);
+        child.emit("close", 0, null);
+        (0, chai_1.expect)(yield waiting).to.equal(0);
+        const log = fs_1.default.readFileSync((0, supervisor_1.publisherLogPath)(workDir), "utf-8");
+        (0, chai_1.expect)(log).to.contain("info: shut down");
+    }));
+    it("reports the exit after LOG_DRAIN_WAIT_MS when the log never closes", () => __awaiter(void 0, void 0, void 0, function* () {
+        const running = yield boot(hostRecording());
+        const clock = sinon_1.default.useFakeTimers({
+            toFake: ["setTimeout", "clearTimeout"],
+        });
+        try {
+            let exited;
+            void running.waitForExit().then((code) => {
+                exited = code;
+            });
+            exitWithoutClose(2);
+            yield clock.tickAsync(supervisor_1.LOG_DRAIN_WAIT_MS - 1);
+            (0, chai_1.expect)(exited).to.equal(undefined);
+            yield clock.tickAsync(1);
+            (0, chai_1.expect)(exited).to.equal(2);
+        }
+        finally {
+            clock.restore();
+        }
+    }));
+    // stdout and stderr are independent, unordered streams. Sharing one buffer
+    // between them lets an stderr write splice into the middle of a readiness
+    // line that arrived in two stdout chunks: the first half still carries the
+    // `PUBLISHER_READY` marker but has lost `environments=`, so the parse
+    // returns undefined and the verdict is never reached. The server then dies
+    // on the 120s boot timeout despite having come up fine — intermittently,
+    // and only on machines where the chunks land that way.
+    // SIGTERM alone left a wedged publisher running and `waitUntilStopped`
+    // blocked on it — a second Ctrl-C only re-sent SIGTERM, so the way out was
+    // killing the CLI from another tab, which is the one path that skips the
+    // config cleanup and leaves a token on disk.
+    it("escalates to SIGKILL when the publisher ignores SIGTERM", () => __awaiter(void 0, void 0, void 0, function* () {
+        const clock = sinon_1.default.useFakeTimers({
+            toFake: ["setTimeout", "clearTimeout"],
+        });
+        try {
+            const host = hostRecording();
+            const running = yield boot(host);
+            running.stop();
+            (0, chai_1.expect)(child.signals).to.eql(["SIGTERM"]);
+            clock.tick(5000);
+            (0, chai_1.expect)(child.signals).to.eql(["SIGTERM", "SIGKILL"]);
+            (0, chai_1.expect)(host.logs.join("\n")).to.contain("did not stop within 5s");
+        }
+        finally {
+            clock.restore();
+        }
+    }));
+    it("does not send SIGKILL to a publisher that stopped when asked", () => __awaiter(void 0, void 0, void 0, function* () {
+        const clock = sinon_1.default.useFakeTimers({
+            toFake: ["setTimeout", "clearTimeout"],
+        });
+        try {
+            const running = yield boot(hostRecording());
+            running.stop();
+            child.exit(0);
+            clock.tick(60000);
+            (0, chai_1.expect)(child.signals).to.eql(["SIGTERM"]);
+        }
+        finally {
+            clock.restore();
+        }
+    }));
+    it("does not stack a second escalation when stopped twice", () => __awaiter(void 0, void 0, void 0, function* () {
+        const clock = sinon_1.default.useFakeTimers({
+            toFake: ["setTimeout", "clearTimeout"],
+        });
+        try {
+            const running = yield boot(hostRecording());
+            running.stop();
+            running.stop();
+            clock.tick(5000);
+            // Two SIGTERMs (one per Ctrl-C) but only ever one SIGKILL.
+            (0, chai_1.expect)(child.signals).to.eql(["SIGTERM", "SIGTERM", "SIGKILL"]);
+        }
+        finally {
+            clock.restore();
+        }
+    }));
+    it("reads a readiness line split across chunks with stderr interleaved", () => __awaiter(void 0, void 0, void 0, function* () {
+        const host = hostRecording();
+        const started = (0, supervisor_1.startPublisher)(options(host, false));
+        yield settle();
+        child.stdout.write("PUBLISHER_READY url=http://127.0.0.1:4000 mcp=http://127.0.0.1:4040 envir");
+        yield settle();
+        child.stderr.write("warn: a package took a while to load\n");
+        yield settle();
+        child.stdout.write("onments=1 packages=1 load_errors=0\n");
+        const running = yield started;
+        (0, chai_1.expect)(running.mcpUrl).to.equal("http://127.0.0.1:4040/mcp");
+    }));
+    it("fails on an init failure written to stderr once the log is complete", () => __awaiter(void 0, void 0, void 0, function* () {
+        const host = hostRecording();
+        const started = (0, supervisor_1.startPublisher)(options(host, false));
+        let failure;
+        started.catch((error) => {
+            failure = error;
+        });
+        yield settle();
+        child.stdout.write("info: loading ");
+        yield settle();
+        child.stderr.write('PUBLISHER_INIT_FAILED error="connection duckdb is reserved"\n');
+        yield settle();
+        // Not thrown while the server is still stopping and writing.
+        (0, chai_1.expect)(failure).to.equal(undefined);
+        (0, chai_1.expect)(child.signals).to.eql(["SIGTERM"]);
+        child.stderr.write("info: closing connections\n");
+        child.exit(null, "SIGTERM");
+        yield (0, chai_1.expect)(started).to.be.rejectedWith("duckdb is reserved");
+        const log = fs_1.default.readFileSync((0, supervisor_1.publisherLogPath)(workDir), "utf-8");
+        (0, chai_1.expect)(log).to.contain("PUBLISHER_INIT_FAILED");
+        (0, chai_1.expect)(log).to.contain("info: closing connections");
+    }));
+    it("does not wait past LOG_DRAIN_WAIT_MS for a server that will not close", () => __awaiter(void 0, void 0, void 0, function* () {
+        const clock = sinon_1.default.useFakeTimers({
+            toFake: ["setTimeout", "clearTimeout"],
+        });
+        try {
+            const started = (0, supervisor_1.startPublisher)(options(hostRecording(), false));
+            let failure;
+            started.catch((error) => {
+                failure = error;
+            });
+            yield settle();
+            child.stderr.write('PUBLISHER_INIT_FAILED error="bad config"\n');
+            yield settle();
+            yield clock.tickAsync(supervisor_1.LOG_DRAIN_WAIT_MS - 1);
+            (0, chai_1.expect)(failure).to.equal(undefined);
+            yield clock.tickAsync(1);
+            (0, chai_1.expect)(failure === null || failure === void 0 ? void 0 : failure.message).to.contain("bad config");
+        }
+        finally {
+            clock.restore();
+        }
+    }));
+    /** A host whose Ctrl-C the test presses, recording the subscription. */
+    function interruptibleHost() {
+        let handler;
+        return Object.assign(Object.assign({}, hostRecording()), { onInterrupt(h) {
+                handler = h;
+                return () => {
+                    handler = undefined;
+                };
+            }, interrupt: () => handler === null || handler === void 0 ? void 0 : handler(), subscribed: () => handler !== undefined });
+    }
+    // The child runs in its own process group, so a terminal Ctrl-C reaches
+    // only the CLI. Unhandled, Node's default exit left the publisher serving on
+    // both ports with the live-token config on disk — and the boot wait, up to
+    // two minutes, is exactly when people press Ctrl-C.
+    it("stops the publisher and removes its token file when interrupted before it is ready", () => __awaiter(void 0, void 0, void 0, function* () {
+        const host = interruptibleHost();
+        const opts = options(host, false);
+        const started = (0, supervisor_1.startPublisher)(opts);
+        yield settle();
+        (0, chai_1.expect)(fs_1.default.existsSync(opts.configPath), "config written at spawn").to.equal(true);
+        host.interrupt();
+        (0, chai_1.expect)(child.signals).to.eql(["SIGTERM"]);
+        child.exit(null, "SIGTERM");
+        try {
+            yield started;
+            chai_1.expect.fail("expected the boot to be abandoned");
+        }
+        catch (error) {
+            (0, chai_1.expect)(error.message).to.equal("Stopped before the local Publisher was ready. It has been shut down.");
+        }
+        (0, chai_1.expect)(fs_1.default.existsSync(opts.configPath)).to.equal(false);
+    }));
+    it("stops a running session on interrupt, and lets go of the signal once it exits", () => __awaiter(void 0, void 0, void 0, function* () {
+        const host = interruptibleHost();
+        const running = yield boot(host);
+        (0, chai_1.expect)(host.subscribed()).to.equal(true);
+        host.interrupt();
+        (0, chai_1.expect)(child.signals).to.eql(["SIGTERM"]);
+        child.exit(null, "SIGTERM");
+        (0, chai_1.expect)(yield running.waitForExit()).to.equal(null);
+        // Unsubscribed: a later Ctrl-C gets the host's default, not a handler
+        // signalling a pid that is gone.
+        (0, chai_1.expect)(host.subscribed()).to.equal(false);
+    }));
+});
+/**
+ * The renewal loop's two signals are different facts: the token on disk is
+ * fresh, and the running server has read it. A renewal that wrote a fresh token
+ * but could not get the server to reload it leaves the first true and the second
+ * false — and the expiry check alone would not look again until the new token
+ * neared its own expiry, while queries failed on the old one.
+ */
+describe("startTokenLoop", () => {
+    let workDir;
+    let clock;
+    beforeEach(() => {
+        workDir = fs_1.default.mkdtempSync((0, path_1.join)(os_1.default.tmpdir(), "token-loop-"));
+        clock = sinon_1.default.useFakeTimers({ toFake: ["setInterval", "clearInterval"] });
+        sinon_1.default.stub(refresh, "ensureFreshTokens").resolves({ status: "fresh" });
+    });
+    afterEach(() => {
+        clock.restore();
+        sinon_1.default.restore();
+        fs_1.default.rmSync(workDir, { recursive: true, force: true });
+    });
+    const ENDPOINTS = {
+        mcpUrl: "http://127.0.0.1:4040/mcp",
+        apiUrl: "http://127.0.0.1:4000",
+    };
+    function loopOptions(secondsLeft, connections = [], store = {}) {
+        var _a;
+        const host = hostRecording();
+        const opts = {
+            directory: workDir,
+            serverRoot: workDir,
+            configPath: (0, path_1.join)(workDir, "publisher.config.json"),
+            config: {
+                frozenConfig: false,
+                environments: [
+                    {
+                        name: "default",
+                        packages: [{ name: "shop", location: workDir }],
+                        connections,
+                    },
+                ],
+            },
+            uiPort: 4000,
+            mcpPort: 4040,
+            watchEnvironment: "default",
+            publisherVersion: "0.0.248",
+            host,
+            credStore: {
+                secondsUntilExpiry: secondsLeft,
+                getApiAccessToken: (_a = store.token) !== null && _a !== void 0 ? _a : (() => "fresh-token"),
+                isTokenValid: () => { var _a, _b; return ({ valid: (_b = (_a = store.valid) === null || _a === void 0 ? void 0 : _a.call(store)) !== null && _b !== void 0 ? _b : true }); },
+            },
+            openBrowser: false,
+        };
+        return { host, opts };
+    }
+    it("retries a reload that failed after a renewal, on the next tick, until it lands", () => __awaiter(void 0, void 0, void 0, function* () {
+        // Due once; after the renewal the token on disk has hours left.
+        let secondsLeft = 60;
+        const { host, opts } = loopOptions(() => secondsLeft);
+        const fetchStub = sinon_1.default.stub(globalThis, "fetch");
+        fetchStub.onCall(0).rejects(new Error("connect ECONNREFUSED"));
+        fetchStub.onCall(1).rejects(new Error("connect ECONNREFUSED"));
+        fetchStub.onCall(2).resolves(new Response("{}", { status: 200 }));
+        const child = new FakeChild();
+        (0, supervisor_1.startTokenLoop)(opts, child, ENDPOINTS, "boot-token");
+        yield clock.tickAsync(supervisor_1.TOKEN_CHECK_INTERVAL_MS);
+        secondsLeft = 7200;
+        (0, chai_1.expect)(fetchStub.callCount, "the renewal's reload").to.equal(1);
+        (0, chai_1.expect)(host.logs.join("\n")).to.contain("Retrying every minute");
+        yield clock.tickAsync(supervisor_1.TOKEN_CHECK_INTERVAL_MS);
+        (0, chai_1.expect)(fetchStub.callCount, "retried although the token is fresh").to.equal(2);
+        yield clock.tickAsync(supervisor_1.TOKEN_CHECK_INTERVAL_MS);
+        (0, chai_1.expect)(fetchStub.callCount).to.equal(3);
+        (0, chai_1.expect)(host.logs.join("\n")).to.contain("The publisher is using the renewed warehouse token.");
+        // Landed: nothing more until the token is due again.
+        yield clock.tickAsync(supervisor_1.TOKEN_CHECK_INTERVAL_MS * 3);
+        (0, chai_1.expect)(fetchStub.callCount).to.equal(3);
+        child.exit(0);
+    }));
+    // `reload_package` recompiles against the connections the server already
+    // holds, so on its own it answered 200 and the old token stayed live. The
+    // connection update is what swaps the credential.
+    it("puts the renewed token into each publisher connection before reloading", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { host, opts } = loopOptions(() => 60, [
+            {
+                name: "credible",
+                type: "publisher",
+                publisherConnection: { connectionUri: "https://dp/api/v0" },
+            },
+            { name: "local", type: "duckdb" },
+        ]);
+        const fetchStub = sinon_1.default
+            .stub(globalThis, "fetch")
+            .callsFake(() => __awaiter(void 0, void 0, void 0, function* () { return new Response("{}", { status: 200 }); }));
+        const child = new FakeChild();
+        (0, supervisor_1.startTokenLoop)(opts, child, ENDPOINTS, "boot-token");
+        yield clock.tickAsync(supervisor_1.TOKEN_CHECK_INTERVAL_MS);
+        (0, chai_1.expect)(fetchStub.callCount, "one update, then one reload").to.equal(2);
+        const [updateUrl, update] = fetchStub.firstCall.args;
+        (0, chai_1.expect)(updateUrl).to.equal("http://127.0.0.1:4000/api/v0/environments/default/connections/credible");
+        (0, chai_1.expect)(update.method).to.equal("PATCH");
+        (0, chai_1.expect)(JSON.parse(String(update.body))).to.eql({
+            publisherConnection: {
+                connectionUri: "https://dp/api/v0",
+                accessToken: "fresh-token",
+            },
+        });
+        (0, chai_1.expect)(fetchStub.secondCall.args[0]).to.equal(ENDPOINTS.mcpUrl);
+        (0, chai_1.expect)(host.logs).to.include("info: Renewed the warehouse token.");
+        child.exit(0);
+    }));
+    it("does not report a renewal the server refused", () => __awaiter(void 0, void 0, void 0, function* () {
+        let secondsLeft = 60;
+        const { host, opts } = loopOptions(() => secondsLeft, [
+            {
+                name: "credible",
+                type: "publisher",
+                publisherConnection: { connectionUri: "https://dp/api/v0" },
+            },
+        ]);
+        const fetchStub = sinon_1.default
+            .stub(globalThis, "fetch")
+            .resolves(new Response("{}", { status: 409 }));
+        const child = new FakeChild();
+        (0, supervisor_1.startTokenLoop)(opts, child, ENDPOINTS, "boot-token");
+        yield clock.tickAsync(supervisor_1.TOKEN_CHECK_INTERVAL_MS);
+        secondsLeft = 7200;
+        (0, chai_1.expect)(fetchStub.callCount, "no reload after a refused update").to.equal(1);
+        (0, chai_1.expect)(host.logs.join("\n")).to.not.contain("Renewed the warehouse token.");
+        (0, chai_1.expect)(host.logs.join("\n")).to.contain("updating connection credible returned HTTP 409");
+        child.exit(0);
+    }));
+    // Nothing awaits the tick, so a throw became an unhandled rejection and the
+    // CLI's handler for those exited: the publisher kept running with its token
+    // file on disk.
+    it("skips a tick whose token check throws, and keeps checking", () => __awaiter(void 0, void 0, void 0, function* () {
+        let calls = 0;
+        const { host, opts } = loopOptions(() => {
+            calls += 1;
+            if (calls === 1)
+                throw new Error("~/.cred is not valid JSON");
+            return 7200;
+        });
+        const unhandled = sinon_1.default.spy();
+        process.on("unhandledRejection", unhandled);
+        const child = new FakeChild();
+        try {
+            (0, supervisor_1.startTokenLoop)(opts, child, ENDPOINTS, "fresh-token");
+            yield clock.tickAsync(supervisor_1.TOKEN_CHECK_INTERVAL_MS);
+            yield new Promise((resolve) => setImmediate(resolve));
+            (0, chai_1.expect)(unhandled.called).to.equal(false);
+            (0, chai_1.expect)(host.logs).to.include("warn: Could not check the warehouse token: ~/.cred is not valid JSON. Trying again in a minute.");
+            yield clock.tickAsync(supervisor_1.TOKEN_CHECK_INTERVAL_MS);
+            (0, chai_1.expect)(calls, "the next tick still ran").to.equal(2);
+        }
+        finally {
+            process.off("unhandledRejection", unhandled);
+            child.exit(0);
+        }
+    }));
+    it("does nothing while the token has life left and no reload is owed", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { opts } = loopOptions(() => 7200);
+        const fetchStub = sinon_1.default.stub(globalThis, "fetch");
+        const child = new FakeChild();
+        (0, supervisor_1.startTokenLoop)(opts, child, ENDPOINTS, "fresh-token");
+        yield clock.tickAsync(supervisor_1.TOKEN_CHECK_INTERVAL_MS * 5);
+        (0, chai_1.expect)(fetchStub.called).to.equal(false);
+        child.exit(0);
+    }));
+    // Another `cred dev`, a `cred` command or the VS Code extension refreshed
+    // ~/.cred first. The token on disk then has hours left, so an expiry check
+    // alone never pushed it, and this server kept the old one until it 401'd.
+    it("pushes a token another process refreshed, although it is not due", () => __awaiter(void 0, void 0, void 0, function* () {
+        let onDisk = "boot-token";
+        const { host, opts } = loopOptions(() => 7200, [
+            {
+                name: "credible",
+                type: "publisher",
+                publisherConnection: { connectionUri: "https://dp/api/v0" },
+            },
+        ], { token: () => onDisk });
+        const fetchStub = sinon_1.default
+            .stub(globalThis, "fetch")
+            .callsFake(() => __awaiter(void 0, void 0, void 0, function* () { return new Response("{}", { status: 200 }); }));
+        const child = new FakeChild();
+        (0, supervisor_1.startTokenLoop)(opts, child, ENDPOINTS, "boot-token");
+        yield clock.tickAsync(supervisor_1.TOKEN_CHECK_INTERVAL_MS);
+        (0, chai_1.expect)(fetchStub.called, "same token as the boot").to.equal(false);
+        onDisk = "refreshed-elsewhere";
+        yield clock.tickAsync(supervisor_1.TOKEN_CHECK_INTERVAL_MS);
+        (0, chai_1.expect)(fetchStub.callCount, "one update, then one reload").to.equal(2);
+        (0, chai_1.expect)(JSON.parse(String(fetchStub.firstCall.args[1].body))).to.eql({
+            publisherConnection: {
+                connectionUri: "https://dp/api/v0",
+                accessToken: "refreshed-elsewhere",
+            },
+        });
+        (0, chai_1.expect)(host.logs).to.include("info: Renewed the warehouse token.");
+        yield clock.tickAsync(supervisor_1.TOKEN_CHECK_INTERVAL_MS * 3);
+        (0, chai_1.expect)(fetchStub.callCount, "nothing more once it is applied").to.equal(2);
+        child.exit(0);
+    }));
+    // Auth0 unreachable while the token still works: say so once, hand the
+    // server nothing (it already has this token), and never claim a renewal.
+    it("warns once and pushes nothing while offline with a valid token", () => __awaiter(void 0, void 0, void 0, function* () {
+        refresh.ensureFreshTokens.resolves({
+            status: "offline",
+            reason: "Could not reach auth.example.",
+        });
+        const { host, opts } = loopOptions(() => 60, [], {
+            token: () => "boot-token",
+        });
+        const fetchStub = sinon_1.default.stub(globalThis, "fetch");
+        const child = new FakeChild();
+        (0, supervisor_1.startTokenLoop)(opts, child, ENDPOINTS, "boot-token");
+        yield clock.tickAsync(supervisor_1.TOKEN_CHECK_INTERVAL_MS * 3);
+        (0, chai_1.expect)(fetchStub.called).to.equal(false);
+        (0, chai_1.expect)(host.logs).to.eql([
+            "warn: Could not reach auth.example. Continuing with the token on disk.",
+        ]);
+        child.exit(0);
+    }));
+    it("says to run cred login, once, when offline and the token has expired", () => __awaiter(void 0, void 0, void 0, function* () {
+        refresh.ensureFreshTokens.resolves({
+            status: "offline",
+            reason: "Could not reach auth.example.",
+        });
+        const { host, opts } = loopOptions(() => -30, [], {
+            token: () => "boot-token",
+            valid: () => false,
+        });
+        const fetchStub = sinon_1.default.stub(globalThis, "fetch");
+        const child = new FakeChild();
+        (0, supervisor_1.startTokenLoop)(opts, child, ENDPOINTS, "boot-token");
+        yield clock.tickAsync(supervisor_1.TOKEN_CHECK_INTERVAL_MS * 3);
+        (0, chai_1.expect)(fetchStub.called).to.equal(false);
+        (0, chai_1.expect)(host.logs).to.eql([
+            "warn: Could not renew the warehouse token: Could not reach auth.example. The token on disk has expired. Queries may start failing until you run `cred login`.",
+        ]);
+        child.exit(0);
+    }));
+    // MCP reports a failed tool call as HTTP 200 with `result.isError`.
+    it("treats a reload the tool reported as failed as a failure, and retries it", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { host, opts } = loopOptions(() => 60);
+        const fetchStub = sinon_1.default.stub(globalThis, "fetch");
+        fetchStub.onCall(0).callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+            return new Response(JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                result: {
+                    isError: true,
+                    content: [
+                        { type: "text", text: "Package shop not found" },
+                    ],
+                },
+            }), { status: 200, headers: { "Content-Type": "application/json" } });
+        }));
+        fetchStub.onCall(1).callsFake(() => __awaiter(void 0, void 0, void 0, function* () { return new Response("{}"); }));
+        const child = new FakeChild();
+        (0, supervisor_1.startTokenLoop)(opts, child, ENDPOINTS, "boot-token");
+        yield clock.tickAsync(supervisor_1.TOKEN_CHECK_INTERVAL_MS);
+        (0, chai_1.expect)(host.logs.join("\n")).to.contain("could not hand it to the publisher: reload of shop failed: Package shop not found");
+        (0, chai_1.expect)(host.logs.join("\n")).to.not.contain("Renewed the warehouse token.");
+        yield clock.tickAsync(supervisor_1.TOKEN_CHECK_INTERVAL_MS);
+        (0, chai_1.expect)(fetchStub.callCount, "retried").to.equal(2);
+        (0, chai_1.expect)(host.logs).to.include("info: The publisher is using the renewed warehouse token.");
+        child.exit(0);
+    }));
+});
+describe("toolCallFailure", () => {
+    it("reads an error out of a server-sent-events frame", () => {
+        const body = 'event: message\ndata: {"jsonrpc":"2.0","id":1,"error":{"code":-32602,"message":"Unknown tool: reload_package"}}\n\n';
+        (0, chai_1.expect)((0, supervisor_1.toolCallFailure)("text/event-stream", body)).to.equal("Unknown tool: reload_package");
+    });
+    it("passes a result that is not flagged as an error", () => {
+        const body = 'data: {"jsonrpc":"2.0","id":1,"result":{"content":[{"type":"text","text":"ok"}]}}\n';
+        (0, chai_1.expect)((0, supervisor_1.toolCallFailure)("text/event-stream", body)).to.equal(undefined);
+    });
+    it("skips a blank data: line, a keep-alive rather than a reply", () => {
+        const body = 'data:\n\ndata: {"jsonrpc":"2.0","id":1,"result":{"content":[{"type":"text","text":"ok"}]}}\n';
+        (0, chai_1.expect)((0, supervisor_1.toolCallFailure)("text/event-stream", body)).to.equal(undefined);
+    });
+    it("counts a body it cannot read as a failure", () => {
+        (0, chai_1.expect)((0, supervisor_1.toolCallFailure)("application/json", "<html>")).to.equal("the server sent a response that could not be read");
+    });
+});
+// Not exercised on Windows here: these pin the command it would run.
+describe("npxLauncher", () => {
+    it("runs npx directly where it is an executable", () => {
+        (0, chai_1.expect)((0, supervisor_1.npxLauncher)("darwin", "/usr/local/bin/node")).to.eql({
+            command: "npx",
+            args: [],
+        });
+    });
+    it("runs npx's script with the running node on Windows", () => {
+        const execPath = (0, path_1.join)("C:", "Program Files", "nodejs", "node.exe");
+        const script = (0, path_1.join)("C:", "Program Files", "nodejs", "node_modules", "npm", "bin", "npx-cli.js");
+        (0, chai_1.expect)((0, supervisor_1.npxLauncher)("win32", execPath, (file) => file === script)).to.eql({
+            command: execPath,
+            args: [script],
+        });
+    });
+    it("refuses clearly on Windows when npx is not beside node", () => {
+        (0, chai_1.expect)(() => (0, supervisor_1.npxLauncher)("win32", "C:/node/node.exe", () => false)).to.throw(/Could not find npx next to C:\/node\/node.exe/);
+    });
+});
+//# sourceMappingURL=supervisor.spec.js.map