@credibledata/cred-cli 0.1.0

package/src/commands/group/getgroup.ts

@@ -0,0 +1,47 @@
+import { GroupsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { printOutError } from "../../utils";
+
+const groupsApi = new GroupsApi(new Configuration());
+
+export async function getGroup(
+   controlPlane: string,
+   groupName: string,
+   debug: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   const organizationName = clientConfig.getOrganization();
+   if (!organizationName) {
+      logger.error("No organization set. Please login or set an organization.");
+      return;
+   }
+
+   logger.info(
+      `Getting group ${groupName} from organization ${organizationName}`,
+   );
+
+   try {
+      const response = await groupsApi.getGroup(organizationName, groupName, {
+         baseURL: controlPlane,
+         headers: {
+            Authorization: clientConfig.getAuthenticationHeader(),
+         },
+      });
+
+      const jsonString = JSON.stringify(response.data, null, 2);
+      console.log(jsonString);
+      logger.info("Group retrieved successfully");
+   } catch (error) {
+      logger.error("Failed to get group");
+      printOutError(error, debug);
+      process.exit(1);
+   }
+}

package/src/commands/group/listgroups.ts

@@ -0,0 +1,45 @@
+import { GroupsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { printOutError } from "../../utils";
+
+const groupsApi = new GroupsApi(new Configuration());
+
+export async function listGroups(controlPlane: string, debug: boolean) {
+   const clientConfig = new ClientConfiguration();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   const organizationName = clientConfig.getOrganization();
+   if (!organizationName) {
+      logger.error("No organization set. Please login or set an organization.");
+      return;
+   }
+
+   logger.info(`Listing groups in organization ${organizationName}`);
+
+   try {
+      const response = await groupsApi.listGroups(organizationName, {
+         baseURL: controlPlane,
+         headers: {
+            Authorization: clientConfig.getAuthenticationHeader(),
+         },
+      });
+
+      const jsonString = JSON.stringify(response.data, null, 2);
+      console.log(jsonString);
+      logger.info("Groups listed successfully");
+   } catch (error) {
+      logger.error("Failed to list groups");
+      printOutError(error, debug);
+      process.exit(1);
+   }
+}
+
+export async function printOutGroups(controlPlane: string, debug: boolean) {
+   return listGroups(controlPlane, debug);
+}

package/src/commands/group/removemember.ts

@@ -0,0 +1,74 @@
+import {
+   GroupMember,
+   GroupsApi,
+   RemoveGroupMembersRequest,
+} from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { UserGroupId } from "../../common/UserGroupId";
+import { logger } from "../../logger";
+import { printOutError } from "../../utils";
+
+const groupsApi = new GroupsApi(new Configuration());
+
+export async function removeMember(
+   controlPlane: string,
+   groupName: string,
+   memberType: string,
+   memberName: string,
+   debug: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   const organizationName = clientConfig.getOrganization();
+   if (!organizationName) {
+      logger.error("No organization set. Please login or set an organization.");
+      return;
+   }
+
+   logger.info(
+      `Removing ${memberType} ${memberName} from group ${groupName} in organization ${organizationName}`,
+   );
+
+   // Create UserGroupId based on member type
+   let userGroupId: UserGroupId;
+   if (memberType.toLowerCase() === "user") {
+      userGroupId = UserGroupId.forUser(memberName);
+   } else if (memberType.toLowerCase() === "group") {
+      userGroupId = UserGroupId.forGroup(memberName);
+   } else {
+      logger.error("Error: memberType must be either 'user' or 'group'");
+      process.exit(1);
+   }
+
+   const groupMember: GroupMember = {
+      userGroupId: userGroupId.getValue(),
+      // Note: status is not required for removal, only the member identifier
+   };
+
+   const request: RemoveGroupMembersRequest = {
+      members: [groupMember],
+   };
+
+   try {
+      await groupsApi.removeGroupMembers(organizationName, groupName, request, {
+         baseURL: controlPlane,
+         headers: {
+            Authorization: clientConfig.getAuthenticationHeader(),
+         },
+      });
+
+      logger.info(
+         `Successfully removed ${memberType} ${memberName} from group ${groupName}`,
+      );
+   } catch (error) {
+      logger.error("Failed to remove member from group");
+      printOutError(error, debug);
+      process.exit(1);
+   }
+}

package/src/commands/groupaccesstoken/createToken.ts

@@ -0,0 +1,68 @@
+import kleur from "kleur";
+import { logger } from "../../logger";
+import { withGroupContext } from "./groupContainer";
+
+export async function createGroupAccessToken(
+    controlPlane: string,
+    groupName: string,
+    tokenName: string,
+    expiresAt: string | undefined,
+    debug: boolean,
+) {
+    // Validate expiresAt format if provided
+    if (expiresAt) {
+        const expiresAtDate = new Date(expiresAt);
+        if (isNaN(expiresAtDate.getTime())) {
+            logger.error(
+                `Invalid expiration date format: ${expiresAt}. Please use ISO 8601 format (e.g., 2025-12-31T23:59:59Z)`,
+            );
+            process.exit(1);
+        }
+        if (expiresAtDate <= new Date()) {
+            logger.error(
+                "Expiration date must be in the future",
+            );
+            process.exit(1);
+        }
+    }
+
+    const result = await withGroupContext(controlPlane, async (context) => {
+        const { organizationName, groupsApi, options } = context;
+
+        logger.info(
+            `Creating access token ${tokenName} for group ${groupName} in organization ${organizationName}${expiresAt ? ` (expires: ${expiresAt})` : ""}`,
+        );
+
+        const response = await groupsApi.createGroupAccessToken(
+            organizationName,
+            groupName,
+            tokenName,
+            expiresAt,
+            options,
+        );
+
+        return response.data;
+    }, undefined, debug);
+
+    // Display security warning after the response is printed
+    console.log("\n" + kleur.yellow().bold("⚠️  IMPORTANT SECURITY NOTICE ⚠️"));
+    console.log(
+        kleur.yellow(
+            "The token secret shown above will NOT be displayed again.",
+        ),
+    );
+    console.log(
+        kleur.yellow(
+            "Please store it securely in a password manager or secure vault.",
+        ),
+    );
+    console.log(
+        kleur.yellow(
+            "If you lose this token, you will need to create a new one.",
+        ),
+    );
+    console.log("");
+    logger.info("Group access token created successfully");
+
+    return result;
+}

package/src/commands/groupaccesstoken/deleteToken.ts

@@ -0,0 +1,24 @@
+import { logger } from "../../logger";
+import { withGroupContext } from "./groupContainer";
+
+export async function deleteGroupAccessToken(
+    controlPlane: string,
+    groupName: string,
+    tokenName: string,
+    debug: boolean,
+) {
+    return withGroupContext(controlPlane, async (context) => {
+        const { organizationName, groupsApi, options } = context;
+
+        logger.info(
+            `Deleting access token ${tokenName} from group ${groupName} in organization ${organizationName}`,
+        );
+
+        await groupsApi.deleteGroupAccessToken(
+            organizationName,
+            groupName,
+            tokenName,
+            options,
+        );
+    }, `Successfully deleted access token ${tokenName}. This token has been immediately revoked.`, debug);
+}

package/src/commands/groupaccesstoken/groupContainer.ts

@@ -0,0 +1,83 @@
+import { GroupsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { printOutError } from "../../utils";
+
+export interface ApiOptions {
+    baseURL: string;
+    headers: {
+        Authorization: string;
+    };
+    params?: Record<string, unknown>;
+}
+
+export interface GroupContext {
+    organizationName: string;
+    groupsApi: GroupsApi;
+    options: ApiOptions;
+}
+
+/**
+ * Container function that handles common ClientConfiguration checks, setup,
+ * error handling, and response printing for group access token operations.
+ * 
+ * @param controlPlane The control plane URL
+ * @param handler The handler function to execute with the configured context
+ * @param successMessage Optional success message to display after the operation
+ * @param debug Whether to enable debug mode for error output
+ * @returns The result of the handler function, or void if validation fails
+ */
+export async function withGroupContext<T>(
+    controlPlane: string,
+    handler: (context: GroupContext) => Promise<T>,
+    successMessage?: string,
+    debug: boolean = false,
+): Promise<T | void> {
+    const clientConfig = new ClientConfiguration();
+
+    if (!clientConfig.doesConfigExists()) {
+        logger.error("Please, make sure that you are logged in");
+        return;
+    }
+
+    const organizationName = clientConfig.getOrganization();
+    if (!organizationName) {
+        logger.error("No organization set. Please login or set an organization.");
+        return;
+    }
+
+    const options: ApiOptions = {
+        baseURL: controlPlane,
+        headers: {
+            Authorization: clientConfig.getAuthenticationHeader(),
+        },
+    };
+
+    const context: GroupContext = {
+        organizationName,
+        groupsApi: new GroupsApi(new Configuration()),
+        options,
+    };
+
+    try {
+        const result = await handler(context);
+
+        // Print response if it exists
+        if (result !== undefined && result !== null) {
+            const jsonString = JSON.stringify(result, null, 2);
+            console.log(jsonString);
+        }
+
+        // Print success message if provided
+        if (successMessage) {
+            logger.info(successMessage);
+        }
+
+        return result;
+    } catch (error) {
+        logger.error("Operation failed");
+        printOutError(error, debug);
+        process.exit(1);
+    }
+}

package/src/commands/groupaccesstoken/listTokens.ts

@@ -0,0 +1,24 @@
+import { logger } from "../../logger";
+import { withGroupContext } from "./groupContainer";
+
+export async function listGroupAccessTokens(
+    controlPlane: string,
+    groupName: string,
+    debug: boolean,
+) {
+    return withGroupContext(controlPlane, async (context) => {
+        const { organizationName, groupsApi, options } = context;
+
+        logger.info(
+            `Listing access tokens for group ${groupName} in organization ${organizationName}`,
+        );
+
+        const response = await groupsApi.listGroupAccessTokens(
+            organizationName,
+            groupName,
+            options,
+        );
+
+        return response.data;
+    }, "Group access tokens listed successfully", debug);
+}

package/src/commands/list.ts

@@ -0,0 +1,90 @@
+import { Command } from "commander";
+import { controlPlanesByEnv, Environment } from "../constants";
+import { listConnections } from "./connection/listconnections";
+import { printOutGroups } from "./group/listgroups";
+import { listGroupAccessTokens } from "./groupaccesstoken/listTokens";
+import { printOutPackages } from "./package/listpackages";
+import { printOutProjects } from "./project/listprojects";
+import { listVersions } from "./version/listversions";
+
+export const registerListCommands = (
+   cli: Command,
+   environment: Environment,
+) => {
+   const list = cli
+      .command("ls")
+      .description("List resources of a given type")
+      .argument("<resource>", "The resource to list");
+
+   list
+      .command("project")
+      .alias("projects")
+      .description("List all projects.")
+      .option("--debug")
+      .action((options) => {
+         printOutProjects(controlPlanesByEnv[environment], options.debug);
+      });
+
+   list
+      .command("connection")
+      .alias("connections")
+      .description("List all connections.")
+      .option("--debug")
+      .action((options) => {
+         listConnections(controlPlanesByEnv[environment], options.debug);
+      });
+
+   list
+      .command("package")
+      .alias("packages")
+      .description("List the packages in the active project.")
+      .option("--debug")
+      .action((options) => {
+         printOutPackages(controlPlanesByEnv[environment], options.debug);
+      });
+
+   list
+      .command("version")
+      .alias("versions")
+      .description("List the versions of a package.")
+      .argument(
+         "<packageName>",
+         "The name of the package to list the versions of.",
+      )
+      .option("--debug")
+      .action((packageName, options) => {
+         listVersions(
+            controlPlanesByEnv[environment],
+            packageName,
+            options.debug,
+         );
+      });
+
+   list
+      .command("group")
+      .alias("groups")
+      .description("List all groups in the organization.")
+      .option("--debug")
+      .action((options) => {
+         printOutGroups(controlPlanesByEnv[environment], options.debug);
+      });
+
+
+   list
+      .command("group-access-token")
+      .alias("group-access-tokens")
+      .description("List all access tokens for a group.")
+      .argument(
+         "<groupName>",
+         "The name of the group",
+      )
+      .option("--debug")
+      .action((groupName, options) => {
+         listGroupAccessTokens(
+            controlPlanesByEnv[environment],
+            groupName,
+            options.debug,
+         );
+      });
+
+};

package/src/commands/misc/login.spec.ts

@@ -0,0 +1,128 @@
+import axios from "axios";
+import { expect } from "chai";
+import fs from "fs";
+import os from "os";
+import { join } from "path";
+import sinon from "sinon";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { login } from "./login";
+
+function createFakeIdToken(payload: Record<string, unknown>): string {
+   const header = Buffer.from(
+      JSON.stringify({ alg: "none", typ: "JWT" }),
+   ).toString("base64url");
+   const body = Buffer.from(JSON.stringify(payload)).toString("base64url");
+   return `${header}.${body}.`;
+}
+
+describe("login", () => {
+   let tmpConfigFilePath: string;
+   let axiosStub: sinon.SinonStub;
+   const mockDeviceCodeResponse = {
+      data: {
+         verification_uri_complete: "https://example.com",
+         user_code: "123456",
+         device_code: "device-code-123",
+         interval: 1,
+      },
+   };
+
+   const fakeJwtPayload = {
+      name: "Test User",
+      email: "test@example.com",
+   };
+
+   const mockedAccessTokenResponse = {
+      data: {
+         id_token: createFakeIdToken(fakeJwtPayload),
+         access_token: "mock-access-token",
+         refresh_token: "mock-refresh-token",
+      },
+   };
+
+   beforeEach(() => {
+      tmpConfigFilePath = join(os.tmpdir(), "cred.json");
+      fs.writeFileSync(tmpConfigFilePath, "{}");
+      axiosStub = sinon.stub(axios, "request");
+   });
+
+   afterEach(() => {
+      fs.rmSync(tmpConfigFilePath);
+      axiosStub.restore();
+   });
+
+   it("should not delete config properties on login", async function () {
+      this.timeout(2000);
+      const config = new ClientConfiguration(tmpConfigFilePath);
+      config.setEnvironment("localhost");
+      config.setOrganization("foo");
+      config.setProject("bar");
+      axiosStub
+         .onFirstCall()
+         .resolves(mockDeviceCodeResponse)
+         .onSecondCall()
+         .resolves(mockedAccessTokenResponse);
+      await login("foo", tmpConfigFilePath);
+      expect(config.getOrganization()).to.equal("foo");
+      expect(config.getProject()).to.equal("bar");
+   });
+
+   it("should change the active organization when login succeeds", async function () {
+      this.timeout(2000);
+      axiosStub
+         .onFirstCall()
+         .resolves(mockDeviceCodeResponse)
+         .onSecondCall()
+         .resolves(mockedAccessTokenResponse);
+      const config = new ClientConfiguration(tmpConfigFilePath);
+      config.setEnvironment("localhost");
+      config.setOrganization("foo");
+      config.setProject("bar");
+      await login("test", tmpConfigFilePath);
+      expect(config.getOrganization()).to.equal("test");
+   });
+
+   it("should set an access token when login succeeds", async function () {
+      this.timeout(2000);
+      axiosStub
+         .onFirstCall()
+         .resolves(mockDeviceCodeResponse)
+         .onSecondCall()
+         .resolves(mockedAccessTokenResponse);
+      const config = new ClientConfiguration(tmpConfigFilePath);
+      await login("test", tmpConfigFilePath);
+      expect(config.getAccessToken()).to.equal(
+         mockedAccessTokenResponse.data.access_token,
+      );
+   });
+
+   it("should unset the project field when switching organizations", async function () {
+      this.timeout(2000);
+      axiosStub
+         .onFirstCall()
+         .resolves(mockDeviceCodeResponse)
+         .onSecondCall()
+         .resolves(mockedAccessTokenResponse);
+      const config = new ClientConfiguration(tmpConfigFilePath);
+      config.setEnvironment("localhost");
+      config.setOrganization("foo");
+      config.setProject("bar");
+      await login("not-foo", tmpConfigFilePath);
+      expect(config.getProject()).to.equal(undefined);
+   });
+
+   it("should not unset the project field when logging in with the same organization", async function () {
+      this.timeout(2000);
+      axiosStub
+         .onFirstCall()
+         .resolves(mockDeviceCodeResponse)
+         .onSecondCall()
+         .resolves(mockedAccessTokenResponse);
+      const config = new ClientConfiguration(tmpConfigFilePath);
+      config.setEnvironment("localhost");
+      config.setOrganization("foo");
+      config.setProject("bar");
+      await login("foo", tmpConfigFilePath);
+      expect(config.getProject()).to.equal("bar");
+   });
+});