@credibledata/cred-cli 0.0.7 → 0.0.102

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,14 @@ 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["config"].activeEnvironment).to.equal("production");
+      expect(() => clientConfig.loadConfig()).to.throw(
+         /Invalid config structure/,
+      );
+      expect(writeFileSyncStub.called).to.be.false;
    });
 
    describe("isTokenValid", () => {
@@ -466,7 +464,8 @@ 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 print error when token is invalid", () => {

package/src/clientconfiguration.ts

@@ -1,3 +1,4 @@
+import crypto from "crypto";
 import fs from "fs";
 import { jwtDecode } from "jwt-decode";
 import kleur from "kleur";
@@ -44,28 +45,35 @@ export class ClientConfiguration {
    }
 
    public loadConfig(): ConfigFile {
+      let fileContents: Buffer | undefined;
       try {
-         const fileContents = fs.readFileSync(this.configPath);
-         this.config = JSON.parse(fileContents.toString());
-         if (
-            !this.config.activeEnvironment ||
-            !this.config.configPerEnvironment
-         ) {
-            throw new Error(
-               "Corrupted config file found, restoring to default settings.",
-            );
-         }
+         fileContents = fs.readFileSync(this.configPath);
       } catch (error) {
-         logger.warn(error);
-         const configPerEnvironment: ConfigFile["configPerEnvironment"] = {};
-         for (const env of ALL_ENVIRONMENTS) {
-            configPerEnvironment[env] = {};
+         if ((error as NodeJS.ErrnoException)?.code === "ENOENT") {
+            // First-time setup: create a default config on disk.
+            this.config = this.defaultConfig();
+            this.writeConfig();
+            return this.config;
          }
-         this.config = {
-            configPerEnvironment,
-            activeEnvironment: "production",
-         };
-         fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+         throw error;
+      }
+
+      try {
+         this.config = JSON.parse(fileContents.toString());
+      } catch (error) {
+         // Non-atomic writes from older binaries, or a manually corrupted file,
+         // can leave `.cred` unparseable. Fail loud rather than silently
+         // overwriting — a silent reset erases the access token for every
+         // subsequent caller on the same machine.
+         throw new Error(
+            `Failed to parse ${this.configPath}: ${error}. The file may be corrupt; re-run \`cred login\` to reset.`,
+         );
+      }
+
+      if (!this.config.activeEnvironment || !this.config.configPerEnvironment) {
+         throw new Error(
+            `Invalid config structure in ${this.configPath}; re-run \`cred login\` to reset.`,
+         );
       }
 
       for (const env of ALL_ENVIRONMENTS) {
@@ -77,13 +85,46 @@ export class ClientConfiguration {
       return this.config;
    }
 
+   private defaultConfig(): ConfigFile {
+      const configPerEnvironment: ConfigFile["configPerEnvironment"] = {};
+      for (const env of ALL_ENVIRONMENTS) {
+         configPerEnvironment[env] = {};
+      }
+      return { configPerEnvironment, activeEnvironment: "production" };
+   }
+
+   // Atomic: write to a sibling temp file, then rename into place.
+   // Readers either see the old file or the new file, never a truncated
+   // zero-byte snapshot (the window that `writeFileSync` exposes between
+   // open(O_TRUNC) and write).
+   //
+   // The temp suffix uses 16 bytes of crypto-random hex so the temp
+   // path is unguessable — a predictable name (pid + Date.now()) lets a
+   // co-located attacker pre-create a symlink at that path and trick
+   // us into clobbering an arbitrary file (CodeQL js/insecure-temporary-file).
+   // O_EXCL on open further refuses to follow a pre-existing entry.
+   private writeConfig(): void {
+      const tmp = `${this.configPath}.${crypto.randomBytes(16).toString("hex")}.tmp`;
+      const fd = fs.openSync(
+         tmp,
+         fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL,
+         0o600,
+      );
+      try {
+         fs.writeFileSync(fd, JSON.stringify(this.config));
+      } finally {
+         fs.closeSync(fd);
+      }
+      fs.renameSync(tmp, this.configPath);
+   }
+
    public setOrganization(organizationName: string) {
       this.loadConfig();
       // TODO: Validate organization exists and user has access.
       const environment = this.getEnvironment();
       this.config.configPerEnvironment[environment].organization =
          organizationName;
-      fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+      this.writeConfig();
    }
 
    public setProject(projectName: string) {
@@ -91,7 +132,7 @@ export class ClientConfiguration {
       // TODO: Validate project exists and user has access.
       const environment = this.getEnvironment();
       this.config.configPerEnvironment[environment].project = projectName;
-      fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+      this.writeConfig();
    }
 
    public getOrganization() {
@@ -112,7 +153,7 @@ export class ClientConfiguration {
       this.config.configPerEnvironment[environment].isServiceAccountToken =
          !userToken;
       this.config.configPerEnvironment[environment].accessToken = accessToken;
-      fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+      this.writeConfig();
    }
 
    public getAuthenticationHeader() {
@@ -135,7 +176,7 @@ export class ClientConfiguration {
       const environment = this.getEnvironment();
       this.config.configPerEnvironment[environment].jwtAccessToken =
          jwtAccessToken;
-      fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+      this.writeConfig();
    }
 
    public getJwtAccessToken(): string | undefined {
@@ -154,7 +195,7 @@ export class ClientConfiguration {
          username,
          email,
       };
-      fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+      this.writeConfig();
    }
 
    public getVSCodeUser(): { username: string; email: string } | undefined {
@@ -167,7 +208,7 @@ export class ClientConfiguration {
       this.loadConfig();
       const environment = this.getEnvironment();
       this.config.configPerEnvironment[environment].refreshToken = refreshToken;
-      fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+      this.writeConfig();
    }
 
    public getRefreshToken(): string | undefined {
@@ -192,13 +233,13 @@ export class ClientConfiguration {
       this.loadConfig();
       const environment = this.getEnvironment();
       this.config.configPerEnvironment[environment] = {};
-      fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+      this.writeConfig();
    }
 
    public setEnvironment(environment: Environment) {
       this.loadConfig();
       this.config.activeEnvironment = environment;
-      fs.writeFileSync(this.configPath, JSON.stringify(this.config));
+      this.writeConfig();
    }
 
    public getEnvironment() {
@@ -252,7 +293,7 @@ export class ClientConfiguration {
 
          console.log(kleur.green(ASCII_TITLE));
          logger.info(`Organization: ${kleur.green(organization || "Not set")}`);
-         logger.info(`Project: ${kleur.green(project || "Not set")}`);
+         logger.info(`Environment: ${kleur.green(project || "Not set")}`);
       } else {
          logger.error("Failed to get status");
          logger.error(

package/src/commands/add.ts

@@ -1,10 +1,12 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { Command } from "commander";
 import { controlPlanesByEnv, Environment } from "../constants";
 import { createConnections } from "./connection/createconnections";
 import { addMember } from "./group/addmember";
 import { createGroup } from "./group/creategroup";
 import { createGroupAccessToken } from "./groupaccesstoken/createToken";
-import { createProject } from "./project/createproject";
+import { createEnvironment } from "./environment/createenvironment";
+import { warnProjectDeprecated } from "./legacy";
 
 export const registerAddCommands = (cli: Command, environment: Environment) => {
    const add = cli
@@ -12,14 +14,41 @@ export const registerAddCommands = (cli: Command, environment: Environment) => {
       .description("Add a resource")
       .argument("<resource>", "The resource to add");
 
+   const addEnvironmentAction = (environmentName: string, options: any) => {
+      createEnvironment(
+         controlPlanesByEnv[environment],
+         environmentName,
+         options.readmeFile,
+         options.replication,
+         options.debug,
+         options.yes,
+      );
+   };
+
+   add.command("environment")
+      .description("Add an environment.")
+      .argument("<environmentName>", "The name of the environment to create.")
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .option(
+         "--readmeFile <readmeFile>",
+         "The path to the readme file for the environment.",
+      )
+      .option(
+         "--replication <replicationCount>",
+         "The replication count (must be at least 1).",
+         parseInt,
+      )
+      .action(addEnvironmentAction);
+
    add.command("project")
-      .description("Add a project.")
-      .argument("<projectName>", "The name of the project to create.")
+      .description("[deprecated] Alias for 'add environment'.")
+      .argument("<projectName>", "The name of the environment to create.")
       .option("--debug")
       .option("-y, --yes", "Skip confirmation.")
       .option(
          "--readmeFile <readmeFile>",
-         "The path to the readme file for the project.",
+         "The path to the readme file for the environment.",
       )
       .option(
          "--replication <replicationCount>",
@@ -27,14 +56,8 @@ export const registerAddCommands = (cli: Command, environment: Environment) => {
          parseInt,
       )
       .action((projectName, options) => {
-         createProject(
-            controlPlanesByEnv[environment],
-            projectName,
-            options.readmeFile,
-            options.replication,
-            options.debug,
-            options.yes,
-         );
+         warnProjectDeprecated("add environment");
+         addEnvironmentAction(projectName, options);
       });
 
    add.command("connection")