@credibledata/cred-cli 0.0.103 → 0.0.105

package/dist/commands/misc/setup.spec.js

@@ -0,0 +1,783 @@
+"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 fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const sinon_1 = __importDefault(require("sinon"));
+const api_1 = require("../../client/api");
+const clientconfiguration_1 = require("../../clientconfiguration");
+const constants_1 = require("../../constants");
+const logger_1 = require("../../logger");
+const flow = __importStar(require("../../setup-core/flow"));
+const host_1 = require("../../setup-core/host");
+const refresh = __importStar(require("../../setup-core/refresh"));
+const folderconfig_1 = require("../../setup-core/folderconfig");
+const setEnvironmentModule = __importStar(require("../environment/setenvironment"));
+const utils = __importStar(require("../../utils"));
+const inquirerHost = __importStar(require("./inquirerHost"));
+const loginModule = __importStar(require("./login"));
+const setup_1 = require("./setup");
+/**
+ * `cred init` / `cred dev` orchestration.
+ *
+ * These two decide which deployment, organization and Credible environment a
+ * directory is wired to, and those answers are baked into `.mcp.json`, the agent
+ * briefing and the publisher config — where getting one wrong looks entirely
+ * normal until someone queries the wrong warehouse. So the assertions here are
+ * about *which* values reach `runSetup`/`wireDirectory` and whether a refusal
+ * stops the flow, not about what those write.
+ *
+ * The credential store is stubbed at the prototype rather than given a temp
+ * file, because `resolveTarget` constructs its own `ClientConfiguration` with no
+ * injection point: an unstubbed run would read — and `loadConfig` would create —
+ * the developer's real `~/.cred`.
+ */
+describe("init and dev", () => {
+    let sandbox;
+    let workDir;
+    let previousCwd;
+    /** The store's per-deployment state, so setProject/getProject behave. */
+    let stored;
+    let runSetupStub;
+    let wireDirectoryStub;
+    let startSessionStub;
+    let loginStub;
+    let setEnvironmentStub;
+    let ensureFreshTokensStub;
+    let exitStub;
+    /** Thrown in place of `process.exit`, so a test can assert the flow stopped. */
+    class Exited extends Error {
+    }
+    beforeEach(() => {
+        sandbox = sinon_1.default.createSandbox();
+        workDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "setup-cmd-"));
+        previousCwd = process.cwd();
+        process.chdir(workDir);
+        stored = { organization: "acme", project: "prod-bars" };
+        sandbox.stub(logger_1.logger);
+        exitStub = sandbox.stub(process, "exit").callsFake(() => {
+            throw new Exited("exited");
+        });
+        // No prompts, no browser, no terminal colours.
+        sandbox.stub(inquirerHost, "createInquirerHost").returns({
+            log: () => undefined,
+            write: () => undefined,
+            confirm: () => __awaiter(void 0, void 0, void 0, function* () { return true; }),
+            select: () => __awaiter(void 0, void 0, void 0, function* () { return ""; }),
+            selectMany: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
+            openUrl: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }),
+        });
+        sandbox.stub(utils, "getConfirmation").resolves(true);
+        // Every read the flow makes of the store, backed by `stored` so a refusal
+        // to write is visible as an unchanged value.
+        // Honours the instance's `environmentOverride`, because that is the whole
+        // mechanism under test: `resolveTarget` builds the store with the resolved
+        // deployment pinned, and a flat stub would hide whether the scoping works.
+        sandbox
+            .stub(clientconfiguration_1.ClientConfiguration.prototype, "getEnvironment")
+            .callsFake(function () {
+            var _a;
+            return ((_a = this.environmentOverride) !== null && _a !== void 0 ? _a : "production");
+        });
+        sandbox
+            .stub(clientconfiguration_1.ClientConfiguration.prototype, "getOrganization")
+            .callsFake(() => stored.organization);
+        sandbox
+            .stub(clientconfiguration_1.ClientConfiguration.prototype, "getProject")
+            .callsFake(() => stored.project);
+        sandbox
+            .stub(clientconfiguration_1.ClientConfiguration.prototype, "setOrganization")
+            .callsFake((value) => {
+            stored.organization = value;
+        });
+        sandbox
+            .stub(clientconfiguration_1.ClientConfiguration.prototype, "setProject")
+            .callsFake((value) => {
+            stored.project = value;
+        });
+        sandbox
+            .stub(clientconfiguration_1.ClientConfiguration.prototype, "isTokenValid")
+            .returns({ valid: true });
+        sandbox
+            .stub(clientconfiguration_1.ClientConfiguration.prototype, "getHeaders")
+            .returns({ Authorization: "Bearer t" });
+        ensureFreshTokensStub = sandbox
+            .stub(refresh, "ensureFreshTokens")
+            .resolves({ status: "fresh" });
+        loginStub = sandbox.stub(loginModule, "login").resolves(undefined);
+        sandbox.stub(loginModule, "resolveOrganization").resolves("acme");
+        // Accepts by default; the interesting cases make it refuse.
+        setEnvironmentStub = sandbox
+            .stub(setEnvironmentModule, "setEnvironment")
+            .callsFake((name) => __awaiter(void 0, void 0, void 0, function* () {
+            if (name !== undefined)
+                stored.project = name;
+            return name !== undefined;
+        }));
+        // The real one probes 127.0.0.1:4000, so a publisher a developer has
+        // running there would make every start in this file refuse.
+        sandbox.stub(flow, "refuseBesideOtherPublisher").resolves();
+        // Only the field the last line reads: whether there is a connection.
+        const wired = {
+            config: { environments: [{ connections: [{ name: "warehouse" }] }] },
+        };
+        runSetupStub = sandbox.stub(flow, "runSetup").resolves({ wired });
+        wireDirectoryStub = sandbox.stub(flow, "wireDirectory").resolves(wired);
+        startSessionStub = sandbox.stub(flow, "startSession").resolves({
+            uiUrl: "http://localhost:4000",
+            waitForExit: () => __awaiter(void 0, void 0, void 0, function* () { return 0; }),
+            stop: () => undefined,
+        });
+    });
+    afterEach(() => {
+        process.chdir(previousCwd);
+        sandbox.restore();
+        fs_1.default.rmSync(workDir, { recursive: true, force: true });
+    });
+    describe("an --environment the organization does not have", () => {
+        it("stops setup rather than wiring the previous answer", () => __awaiter(void 0, void 0, void 0, function* () {
+            // `setEnvironment` reports a refused name and returns WITHOUT writing,
+            // so the store still holds the last run's answer. Checking only for an
+            // empty store passed on that value: setup printed success and wired the
+            // directory to the OLD environment, contradicting the flag just passed.
+            // The refusal is setEnvironment's to print, as the real one does.
+            setEnvironmentStub.callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+                logger_1.logger.error("No environment named 'prod-barz'.");
+                return false;
+            }));
+            yield (0, setup_1.setup)({
+                start: false,
+                open: false,
+                environment: "prod-barz",
+            }).catch((error) => {
+                (0, chai_1.expect)(error).to.be.instanceOf(Exited);
+            });
+            (0, chai_1.expect)(runSetupStub.called, "wired anyway").to.equal(false);
+            (0, chai_1.expect)(exitStub.calledWith(1)).to.equal(true);
+            const reported = logger_1.logger.error
+                .getCalls()
+                .map((call) => String(call.args[0]));
+            (0, chai_1.expect)(reported).to.eql(["No environment named 'prod-barz'."]);
+        }));
+        // The organization has to be in the store before `setEnvironment` can
+        // list its environments. Written and left there, a refused environment
+        // paired the new organization with the old environment in ~/.cred — a
+        // pair nobody chose, which the next unpinned `cred publish` targets.
+        it("leaves ~/.cred as it was, organization included", () => __awaiter(void 0, void 0, void 0, function* () {
+            setEnvironmentStub.callsFake(() => __awaiter(void 0, void 0, void 0, function* () { return false; }));
+            yield (0, setup_1.setup)({
+                start: false,
+                open: false,
+                organization: "other-org",
+                environment: "typo",
+            }).catch((error) => {
+                (0, chai_1.expect)(error).to.be.instanceOf(Exited);
+            });
+            (0, chai_1.expect)(stored).to.eql({ organization: "acme", project: "prod-bars" });
+        }));
+        // Inquirer 8 does not throw on Ctrl-C: it closes the prompt and re-raises
+        // SIGINT at the process, and the prompt's promise never settles. Without
+        // a listener Node then exited with the new organization and no
+        // environment in ~/.cred.
+        it("puts ~/.cred back before exiting when Ctrl-C closes the picker", () => __awaiter(void 0, void 0, void 0, function* () {
+            const once = sandbox.spy(process, "once");
+            let atExit;
+            exitStub.callsFake((code) => {
+                if (code === 130)
+                    atExit = Object.assign({}, stored);
+                throw new Exited("exited");
+            });
+            loginModule.resolveOrganization.resolves("other-org");
+            setEnvironmentStub.callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+                var _a;
+                (0, chai_1.expect)(stored.organization, "written before the picker").to.equal("other-org");
+                // What inquirer does: re-raise SIGINT at the process.
+                const listener = (_a = once
+                    .getCalls()
+                    .find((call) => call.args[0] === "SIGINT")) === null || _a === void 0 ? void 0 : _a.args[1];
+                (0, chai_1.expect)(listener, "nothing listens for SIGINT").to.not.equal(undefined);
+                listener("SIGINT");
+                return true;
+            }));
+            yield (0, setup_1.setup)({ start: false, open: false }).catch((error) => {
+                (0, chai_1.expect)(error).to.be.instanceOf(Exited);
+            });
+            (0, chai_1.expect)(atExit).to.eql({ organization: "acme", project: "prod-bars" });
+        }));
+        it("stops dev too, which is the command that re-points a directory", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, folderconfig_1.writeFolderConfig)(workDir, {
+                organization: "acme",
+                environment: "prod-bars",
+            });
+            setEnvironmentStub.callsFake(() => __awaiter(void 0, void 0, void 0, function* () { return false; }));
+            yield (0, setup_1.dev)({ open: false, environment: "prod-barz" }).catch((error) => {
+                (0, chai_1.expect)(error).to.be.instanceOf(Exited);
+            });
+            (0, chai_1.expect)(wireDirectoryStub.called, "re-wired anyway").to.equal(false);
+            (0, chai_1.expect)(startSessionStub.called).to.equal(false);
+        }));
+        // `cred dev` has no --create-environment, so naming it sent an agent to
+        // Commander's unknown-option error.
+        // dev takes --create-environment like init. Pointing it at
+        // `cred add environment` created on the pin's organization, which is
+        // the wrong one after `cred dev -o other-org`.
+        it("gives dev init's hints, and passes --create-environment through", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, folderconfig_1.writeFolderConfig)(workDir, {
+                organization: "acme",
+                environment: "prod-bars",
+            });
+            // As the real one does: it logs the refusal itself, then says false.
+            setEnvironmentStub.callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+                logger_1.logger.error("No environment named 'typo'.");
+                return false;
+            }));
+            yield (0, setup_1.dev)({ open: false, environment: "typo" }).catch((error) => {
+                (0, chai_1.expect)(error).to.be.instanceOf(Exited);
+            });
+            (0, chai_1.expect)(setEnvironmentStub.firstCall.args[2].hints).to.equal(setEnvironmentModule.INIT_ENVIRONMENT_HINTS);
+            (0, chai_1.expect)(exitStub.firstCall.args[0]).to.equal(1);
+            // One error, the refusal; setup used to add a second saying the same.
+            const reported = logger_1.logger.error
+                .getCalls()
+                .map((call) => String(call.args[0]));
+            (0, chai_1.expect)(reported).to.eql(["No environment named 'typo'."]);
+        }));
+        it("creates a missing environment from dev when --create-environment is passed", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, folderconfig_1.writeFolderConfig)(workDir, {
+                organization: "acme",
+                environment: "prod-bars",
+            });
+            yield (0, setup_1.dev)({
+                open: false,
+                environment: "fresh",
+                createEnvironment: true,
+            }).catch(() => undefined);
+            (0, chai_1.expect)(setEnvironmentStub.firstCall.args[0]).to.equal("fresh");
+            (0, chai_1.expect)(setEnvironmentStub.firstCall.args[2].createIfMissing).to.equal(true);
+        }));
+        it("names --organization, not cred login, when init cannot ask for one", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield (0, setup_1.setup)({ start: false, open: false, environment: "prod-bars" });
+            (0, chai_1.expect)(loginModule.resolveOrganization
+                .firstCall.args[3]).to.equal("--organization <name>");
+        }));
+    });
+    // `cred dev --organization other-org` keeps the pin's environment name. When
+    // other-org lacks it, `setEnvironment` refuses without writing, and the store
+    // still held that same name from before, so a check on the store passed.
+    it("stops dev when the new organization lacks the pinned environment", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, folderconfig_1.writeFolderConfig)(workDir, {
+            organization: "acme",
+            environment: "prod-bars",
+        });
+        setEnvironmentStub.callsFake(() => __awaiter(void 0, void 0, void 0, function* () { return false; }));
+        yield (0, setup_1.dev)({ open: false, organization: "other-org" }).catch((error) => {
+            (0, chai_1.expect)(error).to.be.instanceOf(Exited);
+        });
+        (0, chai_1.expect)(wireDirectoryStub.called, "re-pinned anyway").to.equal(false);
+        (0, chai_1.expect)(stored).to.eql({ organization: "acme", project: "prod-bars" });
+    }));
+    // Bound to the settled pair, so another terminal moving ~/.cred while the
+    // credential question is open cannot redirect the create.
+    it("creates imported connections in the pair it settled, not the store's current one", () => __awaiter(void 0, void 0, void 0, function* () {
+        const create = sandbox
+            .stub(api_1.ConnectionsApi.prototype, "createConnection")
+            .resolves({});
+        yield (0, setup_1.setup)({ start: false, open: false, environment: "staging-bars" });
+        stored.organization = "moved-org";
+        stored.project = "moved-env";
+        yield runSetupStub.firstCall.args[0].createConnection({ name: "warehouse", type: "postgres" }, { dryRun: false });
+        (0, chai_1.expect)(create.firstCall.args.slice(0, 2)).to.eql([
+            "acme",
+            "staging-bars",
+        ]);
+    }));
+    // A pinned package that no longer exists surfaced its question only after
+    // login and the environment write.
+    it("asks dev's unanswerable questions before logging in", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, folderconfig_1.writeFolderConfig)(workDir, {
+            organization: "acme",
+            environment: "prod-bars",
+        });
+        const gate = sandbox
+            .stub(flow, "refuseUnanswerable")
+            .throws(new host_1.NeedsInputError("Which package?", { flag: "--package <dir>" }));
+        yield (0, setup_1.dev)({ open: false, package: "gone" }).catch((error) => {
+            (0, chai_1.expect)(error).to.be.instanceOf(Exited);
+        });
+        (0, chai_1.expect)(gate.firstCall.args[1]).to.eql({
+            connections: "none",
+            skills: undefined,
+            package: "gone",
+        });
+        (0, chai_1.expect)(ensureFreshTokensStub.called, "logged in first").to.equal(false);
+        (0, chai_1.expect)(setEnvironmentStub.called).to.equal(false);
+        (0, chai_1.expect)(exitStub.calledWith(2)).to.equal(true);
+    }));
+    // `dev` can hit the skills question too (a pin with no skills record), and
+    // without a terminal that exit 2 named a flag `dev` did not take.
+    // A Ctrl-C is a requested stop: 130, the shell's code for it, and a line
+    // saying the cleanup ran. It exited 1, which a waiting script reads as a
+    // dead server, and said nothing.
+    it("exits 130 and says so when dev is stopped with Ctrl-C", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, folderconfig_1.writeFolderConfig)(workDir, {
+            organization: "acme",
+            environment: "prod-bars",
+        });
+        startSessionStub.resolves({
+            uiUrl: "http://localhost:4000",
+            waitForExit: () => __awaiter(void 0, void 0, void 0, function* () { return 1; }),
+            stop: () => undefined,
+            interrupted: () => true,
+        });
+        const saved = process.exitCode;
+        try {
+            yield (0, setup_1.dev)({ open: false, yes: true });
+            (0, chai_1.expect)(process.exitCode).to.equal(130);
+        }
+        finally {
+            process.exitCode = saved;
+        }
+        (0, chai_1.expect)(logger_1.logger.info.calledWith("Stopped the local Publisher and removed this session's token file.")).to.equal(true);
+        (0, chai_1.expect)(logger_1.logger.error.called).to.equal(false);
+    }));
+    it("hands dev's --skills to the wiring", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, folderconfig_1.writeFolderConfig)(workDir, {
+            organization: "acme",
+            environment: "prod-bars",
+        });
+        yield (0, setup_1.dev)({ open: false, yes: true, skills: "none" });
+        (0, chai_1.expect)(wireDirectoryStub.firstCall.args[1].skills).to.equal("none");
+    }));
+    it("does not end dev on a plain success line when there are no connections", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, folderconfig_1.writeFolderConfig)(workDir, {
+            organization: "acme",
+            environment: "prod-bars",
+        });
+        wireDirectoryStub.resolves({
+            config: { environments: [{ connections: [] }] },
+        });
+        yield (0, setup_1.dev)({ open: false, yes: true });
+        const infos = logger_1.logger.info.args.map((args) => String(args[0]));
+        (0, chai_1.expect)(infos.some((line) => line.includes("but the environment has no connections, so there is nothing to query yet. To fix it, add one with `cred add connection`, then restart `cred dev`.")), infos.join("\n")).to.equal(true);
+    }));
+    it("wires the environment a flag names when it is accepted", () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, setup_1.setup)({ start: false, open: false, environment: "staging-bars" });
+        (0, chai_1.expect)(runSetupStub.calledOnce).to.equal(true);
+        (0, chai_1.expect)(runSetupStub.firstCall.args[1]).to.include({
+            organization: "acme",
+            credibleEnvironment: "staging-bars",
+        });
+    }));
+    it("clears the stored environment with undefined before opening the picker", () => __awaiter(void 0, void 0, void 0, function* () {
+        // `""` would survive `cred status`'s `getProject() ?? "Not set"` and print
+        // a blank line, so an interrupted setup would report differently from
+        // every other unset-environment path.
+        let clearedTo = "not called";
+        setEnvironmentStub.callsFake((name) => __awaiter(void 0, void 0, void 0, function* () {
+            if (name === undefined) {
+                clearedTo = stored.project;
+                stored.project = "picked-bars";
+            }
+            return true;
+        }));
+        yield (0, setup_1.setup)({ start: false, open: false });
+        (0, chai_1.expect)(clearedTo).to.equal(undefined);
+        (0, chai_1.expect)(runSetupStub.firstCall.args[1]).to.include({
+            credibleEnvironment: "picked-bars",
+        });
+    }));
+    describe("login", () => {
+        it("is given the deployment the store is scoped to", () => __awaiter(void 0, void 0, void 0, function* () {
+            // Without it, login writes the tokens and organization under the file's
+            // global `activeEnvironment`, and setup's own `getOrganization()` check
+            // then reads a slot login never touched — so a directory pinned to a
+            // non-global deployment failed its first run with "Setup needs an
+            // organization", the case the pin exists for.
+            (0, folderconfig_1.writeFolderConfig)(workDir, { deployment: "staging" });
+            ensureFreshTokensStub.resolves({
+                status: "logged-out",
+                reason: "not logged in",
+            });
+            clientconfiguration_1.ClientConfiguration.prototype
+                .isTokenValid.returns({ valid: false });
+            yield (0, setup_1.setup)({
+                start: false,
+                open: false,
+                environment: "staging-bars",
+            });
+            (0, chai_1.expect)(loginStub.calledOnce).to.equal(true);
+            const [organization, controlPlane, configPath, cluster, deployment] = loginStub.firstCall.args;
+            (0, chai_1.expect)(organization).to.equal(undefined);
+            (0, chai_1.expect)(controlPlane).to.equal(constants_1.controlPlanesByEnv["staging"]);
+            (0, chai_1.expect)(configPath).to.equal(undefined);
+            (0, chai_1.expect)(cluster).to.equal("gcp");
+            (0, chai_1.expect)(deployment).to.equal("staging");
+        }));
+        // An AWS login needs the organization up front, and a GCP login without
+        // one opens a picker that exits 2 without a terminal.
+        it("is given the organization the pin names", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, folderconfig_1.writeFolderConfig)(workDir, {
+                deployment: "videoamp",
+                organization: "videoamp",
+                environment: "reports",
+            });
+            ensureFreshTokensStub.resolves({
+                status: "logged-out",
+                reason: "not logged in",
+            });
+            clientconfiguration_1.ClientConfiguration.prototype
+                .isTokenValid.returns({ valid: false });
+            yield (0, setup_1.dev)({ open: false, yes: true });
+            (0, chai_1.expect)(loginStub.calledOnce, "login attempted").to.equal(true);
+            const [organization, , , cluster, deployment] = loginStub.firstCall.args;
+            (0, chai_1.expect)(organization).to.equal("videoamp");
+            (0, chai_1.expect)(cluster).to.equal("aws");
+            (0, chai_1.expect)(deployment).to.equal("videoamp");
+        }));
+        it("is given the organization --organization names, over the pin's", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, folderconfig_1.writeFolderConfig)(workDir, { organization: "acme" });
+            ensureFreshTokensStub.resolves({
+                status: "logged-out",
+                reason: "not logged in",
+            });
+            clientconfiguration_1.ClientConfiguration.prototype
+                .isTokenValid.returns({ valid: false });
+            yield (0, setup_1.setup)({
+                start: false,
+                open: false,
+                organization: "globex",
+                environment: "prod-bars",
+            });
+            (0, chai_1.expect)(loginStub.firstCall.args[0]).to.equal("globex");
+        }));
+        it("is not attempted when the token on disk is live", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield (0, setup_1.setup)({
+                start: false,
+                open: false,
+                environment: "staging-bars",
+            });
+            (0, chai_1.expect)(loginStub.called).to.equal(false);
+        }));
+    });
+    describe("deployment resolution", () => {
+        it("acts against the deployment a directory is pinned to", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, folderconfig_1.writeFolderConfig)(workDir, {
+                deployment: "staging",
+                organization: "acme",
+                environment: "prod-bars",
+            });
+            yield (0, setup_1.dev)({ open: false, environment: "prod-bars" });
+            (0, chai_1.expect)(wireDirectoryStub.calledOnce).to.equal(true);
+            (0, chai_1.expect)(wireDirectoryStub.firstCall.args[0].deployment).to.equal("staging");
+        }));
+    });
+    // `settleTarget` in confirm mode keeps the resolved pair, so a "no" used to
+    // re-wire exactly the pair the user had just declined.
+    it("opens the pickers when dev's confirmation is answered no", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, folderconfig_1.writeFolderConfig)(workDir, {
+            organization: "acme",
+            environment: "prod-bars",
+        });
+        sandbox.stub(utils, "isInteractive").returns(true);
+        utils.getConfirmation.resolves(false);
+        loginModule.resolveOrganization.resolves("globex");
+        setEnvironmentStub.callsFake((name) => __awaiter(void 0, void 0, void 0, function* () {
+            stored.project = name !== null && name !== void 0 ? name : "picked-bars";
+            return true;
+        }));
+        yield (0, setup_1.dev)({ open: false });
+        (0, chai_1.expect)(setEnvironmentStub.calledWith(undefined)).to.equal(true);
+        (0, chai_1.expect)(wireDirectoryStub.firstCall.args[1]).to.include({
+            organization: "globex",
+            credibleEnvironment: "picked-bars",
+        });
+    }));
+    describe("--cell", () => {
+        afterEach(() => {
+            utils.takeCellFlag(["node", "cred"]);
+        });
+        function slots() {
+            const credPath = path_1.default.join(workDir, "slots.cred");
+            fs_1.default.writeFileSync(credPath, JSON.stringify({
+                configPerEnvironment: {
+                    dev: { organization: "pin-org", project: "pin-env" },
+                    staging: { organization: "demo", project: "malloy-samples" },
+                },
+                activeEnvironment: "production",
+            }));
+            return new clientconfiguration_1.ClientConfiguration(credPath);
+        }
+        it("overrides the pin and the global default, taking organization and environment from the flagged cell's slot", () => {
+            (0, folderconfig_1.writeFolderConfig)(workDir, {
+                deployment: "dev",
+                organization: "pin-org",
+                environment: "pin-env",
+            });
+            const target = (0, setup_1.resolveTarget)(workDir, slots(), "staging");
+            (0, chai_1.expect)(target.deployment).to.equal("staging");
+            (0, chai_1.expect)(target.from).to.equal("flag");
+            // The store's own getters are stubbed in this spec; what matters is
+            // that they, and not the pin, supply the pair.
+            (0, chai_1.expect)((0, setup_1.pinnedIdentity)(workDir, target.credStore)).to.eql({
+                organization: target.credStore.getOrganization(),
+                environment: target.credStore.getProject(),
+                from: "global",
+                ignoredPin: "dev",
+            });
+            (0, chai_1.expect)(target.credStore.getOrganization()).to.not.equal("pin-org");
+        });
+        it("keeps the pin's organization and environment when the flag names the pin's own cell", () => {
+            (0, folderconfig_1.writeFolderConfig)(workDir, {
+                deployment: "dev",
+                organization: "pin-org",
+                environment: "pin-env",
+            });
+            const target = (0, setup_1.resolveTarget)(workDir, slots(), "dev");
+            (0, chai_1.expect)((0, setup_1.pinnedIdentity)(workDir, target.credStore)).to.include({
+                organization: "pin-org",
+                from: "folder",
+            });
+        });
+        it("refuses dev when --cell names another cell than the pin, and names init", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, folderconfig_1.writeFolderConfig)(workDir, {
+                deployment: "dev",
+                organization: "acme",
+                environment: "prod-bars",
+            });
+            utils.takeCellFlag(["node", "cred", "--cell", "staging"]);
+            const errors = logger_1.logger.error;
+            yield (0, setup_1.dev)({ open: false, environment: "prod-bars" }).catch((error) => {
+                (0, chai_1.expect)(error).to.be.instanceOf(Exited);
+            });
+            (0, chai_1.expect)(wireDirectoryStub.called, "re-pinned anyway").to.equal(false);
+            (0, chai_1.expect)(errors.firstCall.args[0]).to.contain("--cell staging init");
+        }));
+        it("still re-pins on dev -e when --cell names the pin's own cell", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, folderconfig_1.writeFolderConfig)(workDir, {
+                deployment: "dev",
+                organization: "acme",
+                environment: "prod-bars",
+            });
+            utils.takeCellFlag(["node", "cred", "--cell", "dev"]);
+            setEnvironmentStub.callsFake((name) => __awaiter(void 0, void 0, void 0, function* () {
+                stored.project = name !== null && name !== void 0 ? name : "picked-bars";
+                return true;
+            }));
+            yield (0, setup_1.dev)({ open: false, environment: "other" });
+            (0, chai_1.expect)(wireDirectoryStub.firstCall.args[1].credibleEnvironment).to.equal("other");
+        }));
+        it("says init is re-pinning a directory pinned to another cell", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, folderconfig_1.writeFolderConfig)(workDir, {
+                deployment: "dev",
+                organization: "acme",
+                environment: "prod-bars",
+            });
+            utils.takeCellFlag(["node", "cred", "--cell", "staging"]);
+            const infos = logger_1.logger.info;
+            yield (0, setup_1.setup)({
+                start: false,
+                open: false,
+                environment: "staging-bars",
+            });
+            (0, chai_1.expect)(infos.args.map((a) => a[0])).to.include("re-pinning this directory from dev to staging");
+        }));
+    });
+    describe("credStoreToRefresh", () => {
+        const global = {};
+        it("checks the pinned deployment's login for the commands that act on it", () => {
+            (0, folderconfig_1.writeFolderConfig)(workDir, { deployment: "staging" });
+            for (const command of ["publish", "add connection"]) {
+                const store = (0, setup_1.credStoreToRefresh)(command, workDir, global);
+                (0, chai_1.expect)(store, command).to.not.equal(global);
+                (0, chai_1.expect)(store.getEnvironment(), command).to.equal("staging");
+            }
+        });
+        it("checks the global login for every other command", () => {
+            (0, folderconfig_1.writeFolderConfig)(workDir, { deployment: "staging" });
+            for (const command of ["ls environment", "rm connection", "archive"]) {
+                (0, chai_1.expect)((0, setup_1.credStoreToRefresh)(command, workDir, global), command).to.equal(global);
+            }
+        });
+    });
+    describe("needsNoSession", () => {
+        it("lets a publish dry run through without a login, under either name", () => {
+            (0, chai_1.expect)((0, setup_1.needsNoSession)("publish", { dryRun: true })).to.equal(true);
+            (0, chai_1.expect)((0, setup_1.needsNoSession)("add version", { dryRun: true })).to.equal(true);
+        });
+        it("still refreshes a real publish, and every other command", () => {
+            (0, chai_1.expect)((0, setup_1.needsNoSession)("publish", {})).to.equal(false);
+            (0, chai_1.expect)((0, setup_1.needsNoSession)("add version", { dryRun: false })).to.equal(false);
+            (0, chai_1.expect)((0, setup_1.needsNoSession)("add connection", { dryRun: true })).to.equal(false);
+        });
+    });
+    it("tells someone to run setup first when dev finds no pin", () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, setup_1.dev)({ open: false }).catch((error) => {
+            (0, chai_1.expect)(error).to.be.instanceOf(Exited);
+        });
+        (0, chai_1.expect)(wireDirectoryStub.called).to.equal(false);
+        (0, chai_1.expect)(String(logger_1.logger.error.firstCall.args[0])).to.contain("cred init");
+    }));
+});
+describe("parsePortFlag", () => {
+    it("takes a whole port whose MCP partner, 40 above, is valid too", () => {
+        (0, chai_1.expect)((0, setup_1.parsePortFlag)(undefined)).to.equal(undefined);
+        (0, chai_1.expect)((0, setup_1.parsePortFlag)("4100")).to.equal(4100);
+        (0, chai_1.expect)((0, setup_1.parsePortFlag)("65495")).to.equal(65495);
+    });
+    it("refuses anything else, naming the range and an example", () => {
+        for (const value of ["abc", "4100.5", "-4100", "80", "65496", ""]) {
+            (0, chai_1.expect)(() => (0, setup_1.parsePortFlag)(value), value).to.throw(`--port was given '${value}'. Fix: pass a whole number from 1024 to 65495; the MCP server takes the port 40 above it. Example: --port 4100.`);
+        }
+    });
+});
+/**
+ * The line `cred publish` and `cred add connection` print before they act.
+ *
+ * It exists because the *silent* case was the wrong one. `chooseTarget`
+ * persists the settled organization and environment to `~/.cred` as well as to
+ * the directory's pin, so `cred init` in `repo/pkg-a` moves the global too —
+ * and a later publish from an unpinned `repo/` inherits pkg-a's environment and
+ * used to say nothing at all, because the old line only printed when a pin was
+ * involved.
+ */
+describe("describeIdentity", () => {
+    it("names the pin as the source when the directory has one", () => {
+        (0, chai_1.expect)((0, setup_1.describeIdentity)("production", { organization: "acme", environment: "prod-bars" }, "folder", "folder")).to.equal("acme/prod-bars on production, pinned in .credible/config.json.");
+    });
+    it("says the global fallback is a fallback, and how to stop it being one", () => {
+        const line = (0, setup_1.describeIdentity)("production", { organization: "acme", environment: "pkg-a-env" }, "global", "global");
+        (0, chai_1.expect)(line).to.contain("acme/pkg-a-env");
+        (0, chai_1.expect)(line).to.contain("on production, from your global settings");
+        (0, chai_1.expect)(line).to.contain("~/.cred");
+        (0, chai_1.expect)(line, "the way out has to be in the line").to.contain("cred init");
+        // Its callers, `publish` and `add connection`, have no such flags: a
+        // caller following the line got "unknown option '--organization'".
+        (0, chai_1.expect)(line).to.not.contain("--organization");
+        (0, chai_1.expect)(line).to.not.contain("--environment");
+    });
+    it("names the cell even when it is the ordinary one", () => {
+        // Credentials are per cell: a line that left production out let a
+        // `--cell staging` login read as if it had changed what this one acts on.
+        (0, chai_1.expect)((0, setup_1.describeIdentity)("production", { organization: "acme", environment: "e" }, "folder", "global")).to.contain("on production");
+    });
+    it("names the deployment when it is not the ordinary one", () => {
+        (0, chai_1.expect)((0, setup_1.describeIdentity)("staging", { organization: "acme", environment: "e" }, "folder", "folder")).to.contain("on staging");
+    });
+    it("says --cell set the cell, and names the pin it overrode", () => {
+        (0, chai_1.expect)((0, setup_1.describeIdentity)("staging", {
+            organization: "demo",
+            environment: "malloy-samples",
+            ignoredPin: "dev",
+        }, "global", "flag")).to.equal("demo/malloy-samples on staging, set by --cell (this directory's pin to dev is ignored).");
+    });
+    it("shows a missing value rather than printing undefined", () => {
+        (0, chai_1.expect)((0, setup_1.describeIdentity)("production", { organization: "acme" }, "global", "global")).to.contain("acme/?");
+    });
+});
+// database-design.md §12.5: `cred dev` proxies each READY database under its
+// own name, beside the connections, through the same connection route.
+describe("listProxiedConnections", () => {
+    let sandbox;
+    const store = {
+        getHeaders: () => ({ Authorization: "Bearer t" }),
+    };
+    const httpError = (status) => Object.assign(new Error(`HTTP ${status}`), {
+        isAxiosError: true,
+        response: { status, data: { message: "boom" } },
+    });
+    beforeEach(() => {
+        sandbox = sinon_1.default.createSandbox();
+        sandbox.stub(logger_1.logger);
+        sandbox
+            .stub(api_1.ConnectionsApi.prototype, "listConnections")
+            .resolves({ data: [{ name: "warehouse" }] });
+    });
+    afterEach(() => sandbox.restore());
+    it("appends each READY database under its own name", () => __awaiter(void 0, void 0, void 0, function* () {
+        const list = sandbox
+            .stub(api_1.DatabasesApi.prototype, "listDatabases")
+            .resolves({
+            data: [
+                { name: "credible", status: "READY" },
+                { name: "staging_db", status: "PROVISIONING" },
+                { name: "sales", status: "READY" },
+                { name: "gone", status: "DELETING" },
+            ],
+        });
+        const proxied = yield (0, setup_1.listProxiedConnections)("http://cp", store, "acme", "analytics");
+        (0, chai_1.expect)(proxied.map((c) => c.name)).to.eql([
+            "warehouse",
+            "credible",
+            "sales",
+        ]);
+        (0, chai_1.expect)(list.firstCall.args.slice(0, 4)).to.eql([
+            "acme",
+            "analytics",
+            -1,
+            0,
+        ]);
+    }));
+    it("adds none, quietly, when the deployment has no databases (404)", () => __awaiter(void 0, void 0, void 0, function* () {
+        sandbox
+            .stub(api_1.DatabasesApi.prototype, "listDatabases")
+            .rejects(httpError(404));
+        const proxied = yield (0, setup_1.listProxiedConnections)("http://cp", store, "acme", "analytics");
+        (0, chai_1.expect)(proxied.map((c) => c.name)).to.eql(["warehouse"]);
+        (0, chai_1.expect)(logger_1.logger.warn.called).to.equal(false);
+    }));
+    it("warns and keeps the connections on any other failure", () => __awaiter(void 0, void 0, void 0, function* () {
+        sandbox
+            .stub(api_1.DatabasesApi.prototype, "listDatabases")
+            .rejects(httpError(503));
+        const proxied = yield (0, setup_1.listProxiedConnections)("http://cp", store, "acme", "analytics");
+        (0, chai_1.expect)(proxied.map((c) => c.name)).to.eql(["warehouse"]);
+        (0, chai_1.expect)(String(logger_1.logger.warn.firstCall.args[0])).to.match(/Could not list the databases of 'analytics' \(boom\)/);
+    }));
+});
+//# sourceMappingURL=setup.spec.js.map