@credibledata/cred-cli 0.0.100 → 0.0.103

package/src/index.ts

@@ -8,12 +8,12 @@ import { ClientConfiguration } from "./clientconfiguration";
 import { registerAddCommands } from "./commands/add";
 import { registerGetCommands } from "./commands/get";
 import { registerListCommands } from "./commands/list";
-import { login } from "./commands/misc/login";
+import { isLoginInvocation, login } from "./commands/misc/login";
 import { logout } from "./commands/misc/logout";
 import { setAccessToken } from "./commands/misc/set-access-token";
 import { listPackages } from "./commands/package/listpackages";
 import { publish } from "./commands/package/publish";
-import { listProjects } from "./commands/project/listprojects";
+import { listEnvironments } from "./commands/environment/listenvironments";
 import { registerRmCommands } from "./commands/rm";
 import { registerSetCommands } from "./commands/set";
 import { registerUpdateCommands } from "./commands/update";
@@ -21,10 +21,31 @@ import {
    archiveVersion,
    unarchiveVersion,
 } from "./commands/version/archive-unarchive-version";
-import { ASCII_TITLE, controlPlanesByEnv } from "./constants";
+import { rerun } from "./commands/materialization/rerun";
+import { cancelRun } from "./commands/materialization/cancelrun";
+import {
+   ASCII_TITLE,
+   Cluster,
+   CLUSTER_BY_ENVIRONMENT,
+   controlPlanesByEnv,
+   DEFAULT_ENVIRONMENT_BY_CLUSTER,
+   getCliOrgConfig,
+} from "./constants";
 
 const clientConfig = new ClientConfiguration();
 
+// `cred login` is the documented recovery path for a corrupt `~/.cred`, and the
+// one command whose job is to (re)establish config. The startup reads below —
+// the axios baseURL and every getActiveEnvironment() call during command
+// registration — invoke loadConfig() eagerly at module load, so a corrupt
+// config throws here, before the login action ever runs, dead-ending the very
+// command meant to fix it. Recover up front, but ONLY for login: every other
+// command stays fail-loud (the thrown error still names `cred login` as the
+// fix) so a stray read never silently resets a user's tokens.
+if (isLoginInvocation(process.argv)) {
+   clientConfig.recoverIfCorrupt();
+}
+
 const getActiveEnvironment = () => {
    return clientConfig.getEnvironment();
 };
@@ -110,15 +131,126 @@ cli.command("unarchive")
       );
    });
 
+cli.command("rerun")
+   .description(
+      "Trigger an on-demand run (rebuild/refresh) for a package version. Defaults to a full run (all sources, indexes and pre-aggregations); use --source/--dimension/--measure/--model-file to scope it to a single unit.",
+   )
+   .argument("<packageName>", "The name of the package to run.")
+   .argument("<versionId>", "The version to (re)build (e.g. 0.1.21).")
+   .option("--debug")
+   .option("-y, --yes", "Skip confirmation.")
+   .option("--source <sourceName>", "Scope the run to a single persist source.")
+   .option(
+      "--dimension <dimension>",
+      "Scope the run to a single indexed dimension.",
+   )
+   .option(
+      "--measure <measure>",
+      "Scope the run to a single pre-aggregated measure. Rebuilds the rollup serving it; add --source when the measure is declared at more than one grain.",
+   )
+   .option(
+      "--model-file <modelFilePath>",
+      "Disambiguate a dimension/source defined in more than one model file.",
+   )
+   .option(
+      "--include-upstream",
+      "Also force-rebuild the target's upstream persisted closure (only meaningful with --source/--dimension/--measure).",
+      false,
+   )
+   .action((packageName, versionId, options) => {
+      rerun(
+         controlPlanesByEnv[getActiveEnvironment()],
+         packageName,
+         versionId,
+         {
+            source: options.source,
+            dimension: options.dimension,
+            measure: options.measure,
+            modelFile: options.modelFile,
+            includeUpstream: options.includeUpstream,
+         },
+         options.debug,
+         options.yes,
+      );
+   });
+
+cli.command("cancel-run")
+   .description("Cancel an in-flight (non-terminal) run.")
+   .argument("<packageName>", "The name of the package that owns the run.")
+   .argument("<runId>", "The id of the run to cancel.")
+   .option("--debug")
+   .option("-y, --yes", "Skip confirmation.")
+   .action((packageName, runId, options) => {
+      cancelRun(
+         controlPlanesByEnv[getActiveEnvironment()],
+         packageName,
+         runId,
+         options.debug,
+         options.yes,
+      );
+   });
+
 cli.command("login")
    .description("Login into Credible service.")
    .argument("<organizationName>", "The organization to login to.")
-   .action((organizationName) => {
-      // TODO: Uncomment this when aws videoamp cluster is ready
-      // if (organizationName === "videoamp") {
-      //    clientConfig.setEnvironment("videoamp" as Environment);
-      // }
-      login(organizationName, controlPlanesByEnv[getActiveEnvironment()]);
+   .option(
+      "-c, --cluster <cluster>",
+      "Target cluster: 'gcp' or 'aws'. Defaults to the org's default cluster (gcp for most orgs).",
+   )
+   .action((organizationName, options) => {
+      const orgConfig = getCliOrgConfig(organizationName);
+      const currentEnv = clientConfig.getEnvironment();
+
+      // Determine the target cluster. Precedence:
+      //   1. Explicit -c/--cluster flag.
+      //   2. The org's defaultCluster (from CliOrgConfig), if registered.
+      //   3. The cluster of the current activeEnvironment — i.e. don't touch
+      //      anything. Unregistered orgs with no flag stay wherever the user
+      //      already set themselves via ms2ad set-env.
+      let cluster: Cluster;
+      if (options.cluster !== undefined) {
+         const requested = String(options.cluster).toLowerCase();
+         if (requested !== "gcp" && requested !== "aws") {
+            console.error(
+               `Invalid --cluster value '${options.cluster}'. Must be 'gcp' or 'aws'.`,
+            );
+            process.exit(1);
+         }
+         cluster = requested;
+      } else if (orgConfig) {
+         cluster = orgConfig.defaultCluster;
+      } else {
+         cluster = CLUSTER_BY_ENVIRONMENT[currentEnv];
+      }
+
+      // Unregistered orgs implicitly support only gcp; registered orgs declare
+      // their cluster list. Reject anything else.
+      const supportedClusters: Cluster[] = orgConfig?.supportedClusters ?? [
+         "gcp",
+      ];
+      if (!supportedClusters.includes(cluster)) {
+         console.error(
+            `Organization '${organizationName}' is not available on the ${cluster} cluster.`,
+         );
+         process.exit(1);
+      }
+
+      // Respect a previously-set activeEnvironment if it's already on the chosen
+      // cluster (e.g. `ms2ad set-env staging && cred login demo` stays on staging).
+      // Only flip envs when the current one is on a different cluster.
+      const targetEnv =
+         CLUSTER_BY_ENVIRONMENT[currentEnv] === cluster
+            ? currentEnv
+            : DEFAULT_ENVIRONMENT_BY_CLUSTER[cluster];
+      if (targetEnv !== currentEnv) {
+         clientConfig.setEnvironment(targetEnv);
+      }
+      login(
+         organizationName,
+         controlPlanesByEnv[targetEnv],
+         undefined,
+         cluster,
+      );
    });
 
 cli.command("logout")
@@ -134,7 +266,9 @@ cli.command("set-access-token")
    });
 
 cli.command("status")
-   .description("Shows the currently active organization and project.")
+   .description(
+      "Shows the cell this CLI targets, and the active organization and environment.",
+   )
    .action(() => {
       const config = new ClientConfiguration();
       config.printStatus();
@@ -142,27 +276,50 @@ cli.command("status")
 
 const complete = omelette("credible").tree({
    // CRUD commands
-   get: ["project", "group"],
+   get: [
+      "environment",
+      "project",
+      "group",
+      "permission",
+      "materialization",
+      "index",
+      "run",
+   ],
    ls: [
+      "environment",
       "project",
       "connection",
       "package",
       "version",
+      "materialization",
+      "index",
+      "run",
       "group",
       "group-access-token",
+      "permission",
    ],
-   update: ["project", "package"],
+   update: ["environment", "project", "package"],
    rm: [
+      "environment",
       "project",
       "connection",
       "package",
       "group",
       "member",
       "group-access-token",
+      "permission",
+   ],
+   add: [
+      "environment",
+      "project",
+      "connection",
+      "group",
+      "member",
+      "group-access-token",
+      "permission",
    ],
-   add: ["project", "connection", "group", "member", "group-access-token"],
    // Misc commands
-   set: ["project"],
+   set: ["environment", "project"],
    login: [],
    logout: [],
    "set-access-token": [],
@@ -170,14 +327,26 @@ const complete = omelette("credible").tree({
    publish: [],
    archive: [],
    unarchive: [],
+   rerun: [],
+   "cancel-run": [],
 });
 
 complete.onAsync("$3", async ({ reply, line }) => {
-   const projectRelatedCommands = ["set project", "get project", "rm project"];
-   if (projectRelatedCommands.some((cmd) => line.includes(cmd))) {
+   const environmentRelatedCommands = [
+      "set environment",
+      "get environment",
+      "rm environment",
+      "set project",
+      "get project",
+      "rm project",
+   ];
+   if (environmentRelatedCommands.some((cmd) => line.includes(cmd))) {
       reply(
-         listProjects(controlPlanesByEnv[getActiveEnvironment()], false).then(
-            (result) => result.projects.map((project) => project.name),
+         listEnvironments(
+            controlPlanesByEnv[getActiveEnvironment()],
+            false,
+         ).then((result) =>
+            result.projects.map((environment) => environment.name),
          ),
       );
    }

package/src/logger.ts

@@ -25,9 +25,13 @@ export const logger = winston.createLogger({
       winston.format.splat(),
    ),
    transports: [
-      // Console transport with colored logs
+      // Console transport with colored logs. Error/warn go to stderr so they
+      // never pollute stdout — commands like `cred ls packages` print JSON to
+      // stdout, and a log line landing there makes downstream `JSON.parse`
+      // (e.g. the e2e harness) fail cryptically.
       new winston.transports.Console({
          format: consoleFormat,
+         stderrLevels: ["error", "warn"],
       }),
 
       // NOTE disabled app.log logging