@credibledata/cred-cli 0.0.100 → 0.0.103

package/src/client/base.ts

@@ -2,7 +2,7 @@
 /* eslint-disable */
 /**
  * Credible Admin API
- * The Credible Admin API is a comprehensive REST API that empowers organizations to manage their Malloy data modeling ecosystem with enterprise-grade security and governance. This API provides programmatic access to all administrative functions, enabling seamless integration with existing workflows and automation systems.  ## Key Features  - **Organization Management**: Create and manage organizations with fine-grained access controls - **Project & Package Lifecycle**: Full CRUD operations for projects, packages, and versions - **Connection Management**: Secure database connection configuration and management - **Permission Management**: Granular role-based access control (RBAC) at organization, project, package, workspace, and document levels - **Workspace Management**: Collaborative workspaces for data modeling and analysis - **User & Group Management**: Comprehensive user administration with group-based permissions  ## Resource Hierarchy  The API follows a hierarchical resource structure with fine-grained permission management at each level: ``` Organizations ├── Permissions ├── Projects │   ├── Permissions │   ├── Packages │   │   ├── Permissions │   │   └── Versions │   └── Connections ├── Workspaces │   ├── Permissions │   └── Documents │       └── Permissions └── Groups     ├── Permissions     └── Members  System-Level Resources: ├── Users ├── System Permissions └── Demo Operations ```  ## Authentication & Authorization  All API endpoints require proper authentication. The API implements fine-grained authorization using role-based permissions: - **Admin**: Full access to all resources within scope - **Modeler**: Can create and modify data models and packages - **Viewer**: Read-only access to resources - **Manager**: Workspace management capabilities - **Editor**: Document editing permissions  ## Rate Limiting & Best Practices  - API requests are rate-limited to ensure system stability - Implement proper error handling and retry logic - Cache responses when appropriate to reduce API calls  ## Support & Documentation  For additional support, examples, and integration guides, visit our developer documentation or contact our support team. 
+ * The Credible Admin API is a comprehensive REST API that empowers organizations to manage their Malloy data modeling ecosystem with enterprise-grade security and governance. This API provides programmatic access to all administrative functions, enabling seamless integration with existing workflows and automation systems.  ## Key Features  - **Organization Management**: Create and manage organizations with fine-grained access controls - **Environment & Package Lifecycle**: Full CRUD operations for environments, packages, and versions - **Connection Management**: Secure database connection configuration and management - **Permission Management**: Granular role-based access control (RBAC) at organization, environment, package, workspace, and document levels - **Workspace Management**: Collaborative workspaces for data modeling and analysis - **User & Group Management**: Comprehensive user administration with group-based permissions  ## Resource Hierarchy  The API follows a hierarchical resource structure with fine-grained permission management at each level: ``` Organizations ├── Permissions ├── Environments │   ├── Permissions │   ├── Packages │   │   ├── Permissions │   │   └── Versions │   └── Connections ├── Workspaces │   ├── Permissions │   └── Documents │       └── Permissions └── Groups     ├── Permissions     └── Members  System-Level Resources: ├── Users ├── System Permissions └── Demo Operations ```  ## Authentication & Authorization  All API endpoints require proper authentication. The API implements fine-grained authorization using role-based permissions: - **Admin**: Full access to all resources within scope - **Modeler**: Can create and modify data models and packages - **Viewer**: Read-only access to resources - **Manager**: Workspace management capabilities - **Editor**: Document editing permissions  ## Rate Limiting & Best Practices  - API requests are rate-limited to ensure system stability - Implement proper error handling and retry logic - Cache responses when appropriate to reduce API calls  ## Support & Documentation  For additional support, examples, and integration guides, visit our developer documentation or contact our support team. 
  *
  * The version of the OpenAPI document: v0
  * Contact: support@credibledata.com

package/src/client/common.ts

@@ -2,7 +2,7 @@
 /* eslint-disable */
 /**
  * Credible Admin API
- * The Credible Admin API is a comprehensive REST API that empowers organizations to manage their Malloy data modeling ecosystem with enterprise-grade security and governance. This API provides programmatic access to all administrative functions, enabling seamless integration with existing workflows and automation systems.  ## Key Features  - **Organization Management**: Create and manage organizations with fine-grained access controls - **Project & Package Lifecycle**: Full CRUD operations for projects, packages, and versions - **Connection Management**: Secure database connection configuration and management - **Permission Management**: Granular role-based access control (RBAC) at organization, project, package, workspace, and document levels - **Workspace Management**: Collaborative workspaces for data modeling and analysis - **User & Group Management**: Comprehensive user administration with group-based permissions  ## Resource Hierarchy  The API follows a hierarchical resource structure with fine-grained permission management at each level: ``` Organizations ├── Permissions ├── Projects │   ├── Permissions │   ├── Packages │   │   ├── Permissions │   │   └── Versions │   └── Connections ├── Workspaces │   ├── Permissions │   └── Documents │       └── Permissions └── Groups     ├── Permissions     └── Members  System-Level Resources: ├── Users ├── System Permissions └── Demo Operations ```  ## Authentication & Authorization  All API endpoints require proper authentication. The API implements fine-grained authorization using role-based permissions: - **Admin**: Full access to all resources within scope - **Modeler**: Can create and modify data models and packages - **Viewer**: Read-only access to resources - **Manager**: Workspace management capabilities - **Editor**: Document editing permissions  ## Rate Limiting & Best Practices  - API requests are rate-limited to ensure system stability - Implement proper error handling and retry logic - Cache responses when appropriate to reduce API calls  ## Support & Documentation  For additional support, examples, and integration guides, visit our developer documentation or contact our support team. 
+ * The Credible Admin API is a comprehensive REST API that empowers organizations to manage their Malloy data modeling ecosystem with enterprise-grade security and governance. This API provides programmatic access to all administrative functions, enabling seamless integration with existing workflows and automation systems.  ## Key Features  - **Organization Management**: Create and manage organizations with fine-grained access controls - **Environment & Package Lifecycle**: Full CRUD operations for environments, packages, and versions - **Connection Management**: Secure database connection configuration and management - **Permission Management**: Granular role-based access control (RBAC) at organization, environment, package, workspace, and document levels - **Workspace Management**: Collaborative workspaces for data modeling and analysis - **User & Group Management**: Comprehensive user administration with group-based permissions  ## Resource Hierarchy  The API follows a hierarchical resource structure with fine-grained permission management at each level: ``` Organizations ├── Permissions ├── Environments │   ├── Permissions │   ├── Packages │   │   ├── Permissions │   │   └── Versions │   └── Connections ├── Workspaces │   ├── Permissions │   └── Documents │       └── Permissions └── Groups     ├── Permissions     └── Members  System-Level Resources: ├── Users ├── System Permissions └── Demo Operations ```  ## Authentication & Authorization  All API endpoints require proper authentication. The API implements fine-grained authorization using role-based permissions: - **Admin**: Full access to all resources within scope - **Modeler**: Can create and modify data models and packages - **Viewer**: Read-only access to resources - **Manager**: Workspace management capabilities - **Editor**: Document editing permissions  ## Rate Limiting & Best Practices  - API requests are rate-limited to ensure system stability - Implement proper error handling and retry logic - Cache responses when appropriate to reduce API calls  ## Support & Documentation  For additional support, examples, and integration guides, visit our developer documentation or contact our support team. 
  *
  * The version of the OpenAPI document: v0
  * Contact: support@credibledata.com

package/src/client/configuration.ts

@@ -2,7 +2,7 @@
 /* eslint-disable */
 /**
  * Credible Admin API
- * The Credible Admin API is a comprehensive REST API that empowers organizations to manage their Malloy data modeling ecosystem with enterprise-grade security and governance. This API provides programmatic access to all administrative functions, enabling seamless integration with existing workflows and automation systems.  ## Key Features  - **Organization Management**: Create and manage organizations with fine-grained access controls - **Project & Package Lifecycle**: Full CRUD operations for projects, packages, and versions - **Connection Management**: Secure database connection configuration and management - **Permission Management**: Granular role-based access control (RBAC) at organization, project, package, workspace, and document levels - **Workspace Management**: Collaborative workspaces for data modeling and analysis - **User & Group Management**: Comprehensive user administration with group-based permissions  ## Resource Hierarchy  The API follows a hierarchical resource structure with fine-grained permission management at each level: ``` Organizations ├── Permissions ├── Projects │   ├── Permissions │   ├── Packages │   │   ├── Permissions │   │   └── Versions │   └── Connections ├── Workspaces │   ├── Permissions │   └── Documents │       └── Permissions └── Groups     ├── Permissions     └── Members  System-Level Resources: ├── Users ├── System Permissions └── Demo Operations ```  ## Authentication & Authorization  All API endpoints require proper authentication. The API implements fine-grained authorization using role-based permissions: - **Admin**: Full access to all resources within scope - **Modeler**: Can create and modify data models and packages - **Viewer**: Read-only access to resources - **Manager**: Workspace management capabilities - **Editor**: Document editing permissions  ## Rate Limiting & Best Practices  - API requests are rate-limited to ensure system stability - Implement proper error handling and retry logic - Cache responses when appropriate to reduce API calls  ## Support & Documentation  For additional support, examples, and integration guides, visit our developer documentation or contact our support team. 
+ * The Credible Admin API is a comprehensive REST API that empowers organizations to manage their Malloy data modeling ecosystem with enterprise-grade security and governance. This API provides programmatic access to all administrative functions, enabling seamless integration with existing workflows and automation systems.  ## Key Features  - **Organization Management**: Create and manage organizations with fine-grained access controls - **Environment & Package Lifecycle**: Full CRUD operations for environments, packages, and versions - **Connection Management**: Secure database connection configuration and management - **Permission Management**: Granular role-based access control (RBAC) at organization, environment, package, workspace, and document levels - **Workspace Management**: Collaborative workspaces for data modeling and analysis - **User & Group Management**: Comprehensive user administration with group-based permissions  ## Resource Hierarchy  The API follows a hierarchical resource structure with fine-grained permission management at each level: ``` Organizations ├── Permissions ├── Environments │   ├── Permissions │   ├── Packages │   │   ├── Permissions │   │   └── Versions │   └── Connections ├── Workspaces │   ├── Permissions │   └── Documents │       └── Permissions └── Groups     ├── Permissions     └── Members  System-Level Resources: ├── Users ├── System Permissions └── Demo Operations ```  ## Authentication & Authorization  All API endpoints require proper authentication. The API implements fine-grained authorization using role-based permissions: - **Admin**: Full access to all resources within scope - **Modeler**: Can create and modify data models and packages - **Viewer**: Read-only access to resources - **Manager**: Workspace management capabilities - **Editor**: Document editing permissions  ## Rate Limiting & Best Practices  - API requests are rate-limited to ensure system stability - Implement proper error handling and retry logic - Cache responses when appropriate to reduce API calls  ## Support & Documentation  For additional support, examples, and integration guides, visit our developer documentation or contact our support team. 
  *
  * The version of the OpenAPI document: v0
  * Contact: support@credibledata.com

package/src/client/index.ts

@@ -2,7 +2,7 @@
 /* eslint-disable */
 /**
  * Credible Admin API
- * The Credible Admin API is a comprehensive REST API that empowers organizations to manage their Malloy data modeling ecosystem with enterprise-grade security and governance. This API provides programmatic access to all administrative functions, enabling seamless integration with existing workflows and automation systems.  ## Key Features  - **Organization Management**: Create and manage organizations with fine-grained access controls - **Project & Package Lifecycle**: Full CRUD operations for projects, packages, and versions - **Connection Management**: Secure database connection configuration and management - **Permission Management**: Granular role-based access control (RBAC) at organization, project, package, workspace, and document levels - **Workspace Management**: Collaborative workspaces for data modeling and analysis - **User & Group Management**: Comprehensive user administration with group-based permissions  ## Resource Hierarchy  The API follows a hierarchical resource structure with fine-grained permission management at each level: ``` Organizations ├── Permissions ├── Projects │   ├── Permissions │   ├── Packages │   │   ├── Permissions │   │   └── Versions │   └── Connections ├── Workspaces │   ├── Permissions │   └── Documents │       └── Permissions └── Groups     ├── Permissions     └── Members  System-Level Resources: ├── Users ├── System Permissions └── Demo Operations ```  ## Authentication & Authorization  All API endpoints require proper authentication. The API implements fine-grained authorization using role-based permissions: - **Admin**: Full access to all resources within scope - **Modeler**: Can create and modify data models and packages - **Viewer**: Read-only access to resources - **Manager**: Workspace management capabilities - **Editor**: Document editing permissions  ## Rate Limiting & Best Practices  - API requests are rate-limited to ensure system stability - Implement proper error handling and retry logic - Cache responses when appropriate to reduce API calls  ## Support & Documentation  For additional support, examples, and integration guides, visit our developer documentation or contact our support team. 
+ * The Credible Admin API is a comprehensive REST API that empowers organizations to manage their Malloy data modeling ecosystem with enterprise-grade security and governance. This API provides programmatic access to all administrative functions, enabling seamless integration with existing workflows and automation systems.  ## Key Features  - **Organization Management**: Create and manage organizations with fine-grained access controls - **Environment & Package Lifecycle**: Full CRUD operations for environments, packages, and versions - **Connection Management**: Secure database connection configuration and management - **Permission Management**: Granular role-based access control (RBAC) at organization, environment, package, workspace, and document levels - **Workspace Management**: Collaborative workspaces for data modeling and analysis - **User & Group Management**: Comprehensive user administration with group-based permissions  ## Resource Hierarchy  The API follows a hierarchical resource structure with fine-grained permission management at each level: ``` Organizations ├── Permissions ├── Environments │   ├── Permissions │   ├── Packages │   │   ├── Permissions │   │   └── Versions │   └── Connections ├── Workspaces │   ├── Permissions │   └── Documents │       └── Permissions └── Groups     ├── Permissions     └── Members  System-Level Resources: ├── Users ├── System Permissions └── Demo Operations ```  ## Authentication & Authorization  All API endpoints require proper authentication. The API implements fine-grained authorization using role-based permissions: - **Admin**: Full access to all resources within scope - **Modeler**: Can create and modify data models and packages - **Viewer**: Read-only access to resources - **Manager**: Workspace management capabilities - **Editor**: Document editing permissions  ## Rate Limiting & Best Practices  - API requests are rate-limited to ensure system stability - Implement proper error handling and retry logic - Cache responses when appropriate to reduce API calls  ## Support & Documentation  For additional support, examples, and integration guides, visit our developer documentation or contact our support team. 
  *
  * The version of the OpenAPI document: v0
  * Contact: support@credibledata.com

package/src/clientconfiguration.spec.ts

@@ -22,8 +22,21 @@ describe("ClientConfiguration", () => {
    let clientConfig: ClientConfiguration;
    let readFileSyncStub: sinon.SinonStub;
    let writeFileSyncStub: sinon.SinonStub;
+   let renameSyncStub: sinon.SinonStub;
    let customConfigPath: string;
 
+   // Simulate a real ENOENT from readFileSync (has `.code = "ENOENT"`).
+   // A bare `Error("File not found")` no longer triggers first-time-setup —
+   // loadConfig now rethrows non-ENOENT errors instead of silently masking them.
+   const enoent = () => Object.assign(new Error("ENOENT"), { code: "ENOENT" });
+
+   // Pull the most-recent persisted config payload off the stubs. Atomic writes
+   // go through writeFileSync(tmpPath, json) followed by renameSync(tmp, path).
+   const lastWrittenConfig = () => {
+      const args = writeFileSyncStub.lastCall.args;
+      return JSON.parse(args[1] as string);
+   };
+
    beforeEach(() => {
       customConfigPath = join(os.homedir(), ".cred_test");
       clientConfig = new ClientConfiguration(customConfigPath);
@@ -32,6 +45,7 @@ describe("ClientConfiguration", () => {
 
       readFileSyncStub = sinon.stub(fs, "readFileSync");
       writeFileSyncStub = sinon.stub(fs, "writeFileSync");
+      renameSyncStub = sinon.stub(fs, "renameSync");
    });
 
    afterEach(() => {
@@ -43,7 +57,7 @@ describe("ClientConfiguration", () => {
    });
 
    it("should load the default config if the file does not exist", () => {
-      readFileSyncStub.throws(new Error("File not found"));
+      readFileSyncStub.throws(enoent());
       clientConfig.loadConfig();
       expect(clientConfig["config"]).to.deep.equal({
          configPerEnvironment: fullPerEnv(),
@@ -51,6 +65,21 @@ describe("ClientConfiguration", () => {
       });
    });
 
+   it("should throw loudly when the config file is unparseable", () => {
+      // Non-atomic writes from older binaries can leave `.cred` truncated.
+      // loadConfig must fail loud instead of silently overwriting — a silent
+      // reset erases the access token for every subsequent caller.
+      readFileSyncStub.returns("{ not json");
+      expect(() => clientConfig.loadConfig()).to.throw(/may be corrupt/);
+      expect(writeFileSyncStub.called).to.be.false;
+   });
+
+   it("should throw when readFileSync fails with a non-ENOENT error", () => {
+      const eacces = Object.assign(new Error("EACCES"), { code: "EACCES" });
+      readFileSyncStub.throws(eacces);
+      expect(() => clientConfig.loadConfig()).to.throw(/EACCES/);
+   });
+
    it("should load the config file correctly", () => {
       const mockConfig = {
          configPerEnvironment: {
@@ -92,134 +121,106 @@ describe("ClientConfiguration", () => {
    });
 
    it("should set and get the project correctly", () => {
-      readFileSyncStub.throws(new Error("File not found"));
+      readFileSyncStub.throws(enoent());
       clientConfig.setProject("new-project");
 
-      expect(
-         writeFileSyncStub.calledWith(
-            customConfigPath,
-            JSON.stringify({
-               configPerEnvironment: fullPerEnv({
-                  production: { project: "new-project" },
-               }),
-               activeEnvironment: "production",
-            }),
-         ),
-      ).to.be.true;
+      expect(lastWrittenConfig()).to.deep.equal({
+         configPerEnvironment: fullPerEnv({
+            production: { project: "new-project" },
+         }),
+         activeEnvironment: "production",
+      });
+      expect(renameSyncStub.lastCall.args[1]).to.equal(customConfigPath);
    });
 
    it("should set and get the access token correctly", () => {
-      readFileSyncStub.throws(new Error("File not found"));
+      readFileSyncStub.throws(enoent());
       clientConfig.setAccessToken(false, "token-123");
 
-      expect(
-         writeFileSyncStub.calledWith(
-            customConfigPath,
-            JSON.stringify({
-               configPerEnvironment: fullPerEnv({
-                  production: {
-                     isServiceAccountToken: true,
-                     accessToken: "token-123",
-                  },
-               }),
-               activeEnvironment: "production",
-            }),
-         ),
-      ).to.be.true;
+      expect(lastWrittenConfig()).to.deep.equal({
+         configPerEnvironment: fullPerEnv({
+            production: {
+               isServiceAccountToken: true,
+               accessToken: "token-123",
+            },
+         }),
+         activeEnvironment: "production",
+      });
    });
 
-   it("should clear auth when setting access token", () => {
+   it("should preserve other per-env fields when setting access token", () => {
+      // Valid initial config (with an activeEnvironment so loadConfig accepts it).
       readFileSyncStub.returns(
-         JSON.stringify({ auth: { username: "user", password: "pass" } }),
+         JSON.stringify({
+            configPerEnvironment: {
+               production: {
+                  auth: { username: "user", password: "pass" },
+               },
+            },
+            activeEnvironment: "production",
+         }),
       );
       clientConfig.setAccessToken(true, "new-token");
-      expect(
-         writeFileSyncStub.calledWith(
-            customConfigPath,
-            JSON.stringify({
-               configPerEnvironment: fullPerEnv({
-                  production: {
-                     isServiceAccountToken: false,
-                     accessToken: "new-token",
-                  },
-               }),
-               activeEnvironment: "production",
-            }),
-         ),
-      ).to.be.true;
+      expect(lastWrittenConfig().configPerEnvironment.production).to.deep.equal(
+         {
+            auth: { username: "user", password: "pass" },
+            isServiceAccountToken: false,
+            accessToken: "new-token",
+         },
+      );
    });
 
    it("should set and get organization", () => {
-      readFileSyncStub.throws(new Error("File not found"));
+      readFileSyncStub.throws(enoent());
       clientConfig.setOrganization("my-org");
 
-      expect(
-         writeFileSyncStub.calledWith(
-            customConfigPath,
-            JSON.stringify({
-               configPerEnvironment: fullPerEnv({
-                  production: { organization: "my-org" },
-               }),
-               activeEnvironment: "production",
-            }),
-         ),
-      ).to.be.true;
+      expect(lastWrittenConfig()).to.deep.equal({
+         configPerEnvironment: fullPerEnv({
+            production: { organization: "my-org" },
+         }),
+         activeEnvironment: "production",
+      });
    });
 
    it("should set and get refresh token", () => {
-      readFileSyncStub.throws(new Error("File not found"));
+      readFileSyncStub.throws(enoent());
       clientConfig.setRefreshToken("refresh-token-123");
 
-      expect(
-         writeFileSyncStub.calledWith(
-            customConfigPath,
-            JSON.stringify({
-               configPerEnvironment: fullPerEnv({
-                  production: { refreshToken: "refresh-token-123" },
-               }),
-               activeEnvironment: "production",
-            }),
-         ),
-      ).to.be.true;
+      expect(lastWrittenConfig()).to.deep.equal({
+         configPerEnvironment: fullPerEnv({
+            production: { refreshToken: "refresh-token-123" },
+         }),
+         activeEnvironment: "production",
+      });
    });
 
    it("should set and get VSCode user", () => {
-      readFileSyncStub.throws(new Error("File not found"));
+      readFileSyncStub.throws(enoent());
       clientConfig.setVSCodeUser("testuser", "test@example.com");
 
-      expect(
-         writeFileSyncStub.calledWith(
-            customConfigPath,
-            JSON.stringify({
-               configPerEnvironment: fullPerEnv({
-                  production: {
-                     vsCodeUser: {
-                        username: "testuser",
-                        email: "test@example.com",
-                     },
-                  },
-               }),
-               activeEnvironment: "production",
-            }),
-         ),
-      ).to.be.true;
+      expect(lastWrittenConfig()).to.deep.equal({
+         configPerEnvironment: fullPerEnv({
+            production: {
+               vsCodeUser: {
+                  username: "testuser",
+                  email: "test@example.com",
+               },
+            },
+         }),
+         activeEnvironment: "production",
+      });
    });
 
    it("should set and get JWT access token", () => {
-      readFileSyncStub.throws(new Error("File not found"));
+      readFileSyncStub.throws(enoent());
       clientConfig.setJwtAccessToken("jwt-token-abc");
 
-      expect(
-         writeFileSyncStub.calledWith(
-            customConfigPath,
-            JSON.stringify({
-               configPerEnvironment: fullPerEnv({
-                  production: { jwtAccessToken: "jwt-token-abc" },
-               }),
-               activeEnvironment: "production",
-            }),
-         ),
-      ).to.be.true;
+      expect(lastWrittenConfig()).to.deep.equal({
+         configPerEnvironment: fullPerEnv({
+            production: { jwtAccessToken: "jwt-token-abc" },
+         }),
+         activeEnvironment: "production",
+      });
    });
 
    it("should return true for doesConfigExists when environment config exists", () => {
@@ -248,26 +249,20 @@ describe("ClientConfiguration", () => {
       readFileSyncStub.returns(JSON.stringify(mockConfig));
       clientConfig.destroyConfig();
 
-      const lastWrite = writeFileSyncStub.lastCall.args[1] as string;
-      expect(JSON.parse(lastWrite)).to.deep.equal({
+      expect(lastWrittenConfig()).to.deep.equal({
          configPerEnvironment: fullPerEnv(),
          activeEnvironment: "production",
       });
    });
 
    it("should set and get environment", () => {
-      readFileSyncStub.throws(new Error("File not found"));
+      readFileSyncStub.throws(enoent());
       clientConfig.setEnvironment("staging");
 
-      expect(
-         writeFileSyncStub.calledWith(
-            customConfigPath,
-            JSON.stringify({
-               configPerEnvironment: fullPerEnv(),
-               activeEnvironment: "staging",
-            }),
-         ),
-      ).to.be.true;
+      expect(lastWrittenConfig()).to.deep.equal({
+         configPerEnvironment: fullPerEnv(),
+         activeEnvironment: "staging",
+      });
    });
 
    it("should return headers with Bearer token for user tokens", () => {
@@ -308,11 +303,82 @@ describe("ClientConfiguration", () => {
       expect(headers.Authorization).to.equal("ApiKey service-token");
    });
 
-   it("should reset to defaults when config file is corrupted (missing activeEnvironment)", () => {
+   it("should throw when config file is missing activeEnvironment", () => {
+      // Previously loadConfig silently reset to defaults — that turned one
+      // corrupt read into permanent state loss for every caller. Now we fail loud.
       readFileSyncStub.returns(JSON.stringify({ configPerEnvironment: {} }));
-      clientConfig.loadConfig();
+      expect(() => clientConfig.loadConfig()).to.throw(
+         /Invalid config structure/,
+      );
+      expect(writeFileSyncStub.called).to.be.false;
+   });
+
+   describe("recoverIfCorrupt", () => {
+      it("returns null and writes nothing when the config is already valid", () => {
+         readFileSyncStub.returns(
+            JSON.stringify({
+               configPerEnvironment: {},
+               activeEnvironment: "staging",
+            }),
+         );
+
+         expect(clientConfig.recoverIfCorrupt()).to.be.null;
+         expect(renameSyncStub.called).to.be.false;
+         // Valid config preserved — active environment untouched.
+         expect(clientConfig.getEnvironment()).to.equal("staging");
+      });
+
+      it("backs up an unparseable file and resets to defaults", () => {
+         readFileSyncStub.returns("{ not json");
+
+         const backupPath = clientConfig.recoverIfCorrupt();
+
+         expect(backupPath).to.match(
+            new RegExp(`${customConfigPath}\\.corrupt-[0-9a-f]{16}$`),
+         );
+         // Renamed aside, never deleted, so the bad file is recoverable.
+         expect(renameSyncStub.calledWith(customConfigPath, backupPath!)).to.be
+            .true;
+         expect(lastWrittenConfig()).to.deep.equal({
+            configPerEnvironment: fullPerEnv(),
+            activeEnvironment: "production",
+         });
+      });
+
+      it("backs up a structurally-invalid file and resets to defaults", () => {
+         readFileSyncStub.returns(JSON.stringify({ configPerEnvironment: {} }));
+
+         const backupPath = clientConfig.recoverIfCorrupt();
+
+         expect(backupPath).to.be.a("string");
+         expect(renameSyncStub.calledWith(customConfigPath, backupPath!)).to.be
+            .true;
+         expect(lastWrittenConfig().activeEnvironment).to.equal("production");
+      });
+
+      it("rethrows fs errors (e.g. EACCES) instead of masking them as a reset", () => {
+         // A permissions problem must surface — resetting would just fail to
+         // write anyway, and silently "recovering" would hide the real cause.
+         const eacces = Object.assign(new Error("EACCES"), { code: "EACCES" });
+         readFileSyncStub.throws(eacces);
+
+         expect(() => clientConfig.recoverIfCorrupt()).to.throw(/EACCES/);
+         expect(renameSyncStub.called).to.be.false;
+      });
+
+      it("creates a fresh default when the file is absent (ENOENT)", () => {
+         readFileSyncStub.throws(enoent());
 
-      expect(clientConfig["config"].activeEnvironment).to.equal("production");
+         // First-time setup is not corruption — nothing to back up. (The atomic
+         // write of the new default does call renameSync, but never to a
+         // `.corrupt-` backup path.)
+         expect(clientConfig.recoverIfCorrupt()).to.be.null;
+         expect(
+            renameSyncStub
+               .getCalls()
+               .some((c) => String(c.args[1]).includes(".corrupt-")),
+         ).to.be.false;
+      });
    });
 
    describe("isTokenValid", () => {
@@ -466,7 +532,66 @@ describe("ClientConfiguration", () => {
 
          expect(loggerStub.info.calledWith(sinon.match("Organization:"))).to.be
             .true;
-         expect(loggerStub.info.calledWith(sinon.match("Project:"))).to.be.true;
+         expect(loggerStub.info.calledWith(sinon.match("Environment:"))).to.be
+            .true;
+      });
+
+      it("should name the targeted cell when the token is valid", () => {
+         const payload = { exp: Math.floor(Date.now() / 1000) + 3600 };
+         const fakeJwt =
+            Buffer.from(JSON.stringify({ alg: "HS256" })).toString(
+               "base64url",
+            ) +
+            "." +
+            Buffer.from(JSON.stringify(payload)).toString("base64url") +
+            ".signature";
+
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {},
+               staging: {},
+               localhost: {},
+               dev: {
+                  accessToken: fakeJwt,
+                  isServiceAccountToken: false,
+                  organization: "demo",
+                  project: "demo",
+               },
+            },
+            activeEnvironment: "dev",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         clientConfig.printStatus();
+
+         expect(loggerStub.info.calledWith(sinon.match("Cell:"))).to.be.true;
+         expect(loggerStub.info.calledWith(sinon.match("dev"))).to.be.true;
+         expect(
+            loggerStub.info.calledWith(
+               sinon.match("https://dev-admin.credibledata.com/api/v0"),
+            ),
+         ).to.be.true;
+      });
+
+      it("should name the targeted cell even when the token is invalid", () => {
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {},
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "localhost",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         clientConfig.printStatus();
+
+         expect(loggerStub.info.calledWith(sinon.match("Cell:"))).to.be.true;
+         expect(
+            loggerStub.info.calledWith(
+               sinon.match("http://admin.ms2.localhost/api/v0"),
+            ),
+         ).to.be.true;
       });
 
       it("should print error when token is invalid", () => {