@dsmrt/axiom-cli 0.0.11 → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# @dsmrt/axiom-cli
+
+## 0.1.0
+
+### Minor Changes
+
+- c3ffa47: Updating build and publishing tools to use tsup for esm support and @changesets/cli
+
+### Patch Changes
+
+- 533b167: trying to figure out changeset
+- Updated dependencies [c3ffa47]
+- Updated dependencies [533b167]
+  - @dsmrt/axiom-aws-sdk@0.1.0
+  - @dsmrt/axiom-config@0.1.0

package/dist/bin/axiom.d.mts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/{lib → dist}/bin/axiom.d.ts

@@ -1,2 +1 @@
 #!/usr/bin/env node
-export {};

package/dist/bin/axiom.js

@@ -0,0 +1,403 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/bin/axiom.ts
+var import_yargs = __toESM(require("yargs"));
+
+// src/commands/config.ts
+var import_axiom_config = require("@dsmrt/axiom-config");
+var Config = class {
+  command = "config";
+  describe = "print the config";
+  builder = (args) => {
+    args.option("env", {
+      type: "string"
+    });
+    return args;
+  };
+  handler = async (args) => {
+    console.log(await this.loadConfig(args));
+  };
+  loadConfig = async (args) => {
+    return (0, import_axiom_config.loadConfig)(args);
+  };
+};
+
+// src/commands/params/base.ts
+var ParamsCommand = class {
+  command = "params";
+  describe = "Manage SSM parameters";
+  builder = (args) => {
+    args.demandCommand().command(new GetCommand()).command(new SetCommand()).command(new DeleteCommand());
+    return args;
+  };
+  handler = async () => {
+    console.log("\u{1F44D}");
+  };
+};
+
+// src/commands/params/get.ts
+var import_axiom_config2 = require("@dsmrt/axiom-config");
+var import_axiom_aws_sdk = require("@dsmrt/axiom-aws-sdk");
+var import_client_ssm = require("@aws-sdk/client-ssm");
+
+// src/aws/credentials-provider.ts
+var import_credential_providers = require("@aws-sdk/credential-providers");
+var import_client_sts = require("@aws-sdk/client-sts");
+var import_inquirer = __toESM(require("inquirer"));
+
+// src/cache.ts
+var import_os = __toESM(require("os"));
+var import_fs = __toESM(require("fs"));
+var DEFAULT_DIRECTORY = `${import_os.default.homedir()}/.axiom/cache`;
+var cache_default = class {
+  constructor(cacheDir = DEFAULT_DIRECTORY) {
+    this.cacheDir = cacheDir;
+  }
+  get(name) {
+    const file = `${this.cacheDir}/${name}`;
+    if (!import_fs.default.existsSync(file)) {
+      return;
+    }
+    const buffer = import_fs.default.readFileSync(file);
+    const item = JSON.parse(buffer.toString());
+    if (item.expires === void 0) {
+      return item.data;
+    }
+    item.expires = new Date(item.expires);
+    if (item.expires < /* @__PURE__ */ new Date()) {
+      this.delete(name);
+      return;
+    }
+    return item.data;
+  }
+  delete(name) {
+    import_fs.default.unlinkSync(`${this.cacheDir}/${name}`);
+  }
+  set(name, value, expires) {
+    if (!import_fs.default.existsSync(this.cacheDir)) {
+      import_fs.default.mkdirSync(this.cacheDir, {
+        recursive: true,
+        mode: 448
+      });
+    }
+    import_fs.default.writeFileSync(
+      `${this.cacheDir}/${name}`,
+      JSON.stringify({
+        expires,
+        data: value
+      }),
+      {
+        mode: 384
+      }
+    );
+  }
+};
+
+// src/aws/credentials-provider.ts
+var CACHE_KEY_PREFIX = "axiom#aws-credentials";
+var cache = new cache_default();
+var returnCredentialsFromAssumerole = (creds) => {
+  return {
+    accessKeyId: `${creds.AccessKeyId}`,
+    secretAccessKey: `${creds.SecretAccessKey}`,
+    sessionToken: `${creds.SessionToken}`
+  };
+};
+var CachedCredentialViaProfileAndRegion = async (profile, region) => {
+  const cacheKeyName = `${CACHE_KEY_PREFIX}#${profile}`;
+  const creds = cache.get(cacheKeyName);
+  if (creds !== void 0) {
+    return async () => returnCredentialsFromAssumerole(creds);
+  }
+  return (0, import_credential_providers.fromNodeProviderChain)({
+    profile,
+    roleAssumer: roleAssumerCallable({
+      region: region ?? "us-east-1",
+      cacheKeyName
+    }),
+    mfaCodeProvider
+  });
+};
+var roleAssumerCallable = (config) => {
+  return async (sourceCreds, params) => {
+    const command = new import_client_sts.AssumeRoleCommand(params);
+    const client = new import_client_sts.STSClient({
+      region: config.region,
+      credentials: sourceCreds
+    });
+    const result = await client.send(command);
+    const creds = result.Credentials;
+    if (creds === void 0 || creds?.AccessKeyId === void 0 || creds?.SecretAccessKey === void 0 || creds?.SessionToken === void 0) {
+      throw new Error("Unable to fetch credentials.");
+    }
+    cache.set(config.cacheKeyName, creds, creds.Expiration);
+    return returnCredentialsFromAssumerole(creds);
+  };
+};
+var mfaCodeProvider = async (mfaSerial) => {
+  const mfaCode = await import_inquirer.default.prompt({
+    name: "code",
+    message: `Enter MFA code for ${mfaSerial}: `,
+    type: "password"
+  });
+  return mfaCode.code;
+};
+var CachedCredentialProvider = (config) => {
+  return CachedCredentialViaProfileAndRegion(config.profile, config.region);
+};
+
+// src/options.ts
+var commonOptions = () => {
+  return {
+    env: {
+      string: true,
+      desc: "Environment name like, prod, staging, dev, etc."
+    }
+  };
+};
+var awsOptions = () => {
+  return {
+    account: {
+      string: true,
+      desc: "AWS Account number like, 1243944546"
+    },
+    region: {
+      string: true,
+      desc: "AWS region like, us-east-1"
+    },
+    profile: {
+      string: true,
+      desc: "AWS configured profile"
+    },
+    baseParameterPath: {
+      string: true,
+      desc: "SSM parameter path base where configs like secrets and infrastucture managed items are set"
+    }
+  };
+};
+
+// src/commands/params/utils.ts
+var buildPath = (config, path) => {
+  if (path === void 0) {
+    return config.aws?.baseParameterPath;
+  }
+  if (/^\//.test(path)) {
+    return path;
+  }
+  return `${config.aws?.baseParameterPath.replace(/\/$/, "")}/${path}`;
+};
+
+// src/commands/params/get.ts
+var import_chalk = __toESM(require("chalk"));
+var GetCommand = class {
+  command = "get [path]";
+  describe = "Get all parameters under the base path";
+  builder = (args) => {
+    const config = (0, import_axiom_config2.loadConfig)();
+    args.options({ ...commonOptions(), ...awsOptions() });
+    args.positional("path", {
+      type: "string",
+      describe: `OPTIONAL path to parameter. Supports absolute and relative paths.
+Example: "/root/myParam" or "service/secret" (which translates to, "${buildPath(
+        config,
+        "service/secret"
+      )})`
+      // default: config.awsSsmParameterPath,
+    });
+    return args;
+  };
+  handler = async (args) => {
+    const config = (0, import_axiom_config2.loadConfig)({ env: args.env });
+    const collection = new import_axiom_aws_sdk.ParameterCollection(
+      config.aws?.baseParameterPath,
+      new import_client_ssm.SSMClient({
+        region: config.aws.region,
+        credentials: await CachedCredentialProvider({
+          profile: config.aws.profile,
+          region: config.aws.region,
+          baseParameterPath: config.aws.baseParameterPath,
+          account: config.aws.account
+        })
+      })
+    );
+    const params = await collection.get();
+    params.forEach((parameter) => {
+      console.log(
+        import_chalk.default.gray(
+          parameter.Name?.replace(/\/([^/]+)$/, "/" + import_chalk.default.bold.green("$1"))
+        ),
+        import_chalk.default.bold.white(parameter.Value)
+      );
+    });
+  };
+};
+
+// src/commands/params/set.ts
+var import_axiom_config3 = require("@dsmrt/axiom-config");
+var import_inquirer2 = __toESM(require("inquirer"));
+var import_client_ssm2 = require("@aws-sdk/client-ssm");
+var import_chalk2 = __toESM(require("chalk"));
+var SetCommand = class {
+  command = "set <path> <value>";
+  describe = "Set all parameters under the base path";
+  builder = (args) => {
+    const config = (0, import_axiom_config3.loadConfig)();
+    args.positional("path", {
+      type: "string",
+      describe: `Path to parameter. Supports absolute and relative paths.
+Example: "/root/myParam" or "service/secret" (which translates to, "${buildPath(
+        config,
+        "service/secret"
+      )})`
+    });
+    args.demandOption("path", "Path is required");
+    args.positional("value", {
+      type: "string"
+    });
+    args.demandOption("value", "Value is required");
+    args.option("force", {
+      boolean: true,
+      default: false,
+      describe: "force set parameter without prompt",
+      alias: "f"
+    });
+    args.option("secure", {
+      boolean: true,
+      default: true,
+      describe: "Save parameter as a secure string"
+    });
+    args.option("overwrite", {
+      boolean: true,
+      default: true,
+      describe: "Overwrite parameter if it already exists"
+    });
+    return args.options({
+      ...commonOptions(),
+      ...awsOptions()
+    });
+  };
+  handler = async (args) => {
+    const config = (0, import_axiom_config3.loadConfig)({ env: args.env });
+    if (args.force !== true) {
+      const res = await import_inquirer2.default.prompt({
+        type: "confirm",
+        name: "setParam",
+        message: `Are you sure you want to set '${args.path}'?`
+      });
+      if (!res.setParam) {
+        console.log("Doing nothing.");
+        return;
+      }
+    }
+    const client = new import_client_ssm2.SSMClient({
+      region: config.aws.region,
+      credentials: await CachedCredentialProvider(config.aws)
+    });
+    const params = await client.send(
+      new import_client_ssm2.PutParameterCommand({
+        Name: buildPath(config, args.path),
+        Value: args.value,
+        Type: args.secure ? import_client_ssm2.ParameterType.SECURE_STRING : import_client_ssm2.ParameterType.STRING,
+        Overwrite: args.overwrite
+      })
+    );
+    console.log(import_chalk2.default.green("Version: "), import_chalk2.default.white.bold(params.Version));
+  };
+};
+
+// src/commands/params/delete.ts
+var import_axiom_config4 = require("@dsmrt/axiom-config");
+var import_inquirer3 = __toESM(require("inquirer"));
+var import_client_ssm3 = require("@aws-sdk/client-ssm");
+var log = console.log;
+var DeleteCommand = class {
+  command = "delete <path>";
+  describe = "Delete SSM parameters";
+  client;
+  builder = (args) => {
+    const config = (0, import_axiom_config4.loadConfig)();
+    args.positional("path", {
+      type: "string",
+      describe: `Path to parameter. Supports absolute and relative paths.
+Example: "/root/myParam" or "service/secret" (which translates to, "${buildPath(
+        config,
+        "service/secret"
+      )})`,
+      default: config.aws?.baseParameterPath,
+      demandOption: true
+    }).demandOption("path", "Path is required");
+    args.option("force", {
+      boolean: true,
+      default: false,
+      describe: "force delete parameter without prompt",
+      alias: "f"
+    });
+    return args;
+  };
+  handler = async (args) => {
+    const config = (0, import_axiom_config4.loadConfig)({ env: args.env });
+    const path = buildPath(args, args.path);
+    const client = new import_client_ssm3.SSMClient({
+      region: config.aws?.region,
+      credentials: await CachedCredentialProvider(config.aws)
+    });
+    if (path === args.aws.baseParameterPath) {
+      throw new Error(
+        `Deleting the path (path: ${path}) that matches the base path (awsSsmParameterPath: ${args.awsSsmParameterPath}) is prohibited.`
+      );
+    }
+    if (args.force !== true) {
+      const res = await import_inquirer3.default.prompt({
+        type: "confirm",
+        name: "delete",
+        message: `Are you sure you want to delete '${path}'?`
+      });
+      if (!res.delete) {
+        log("Doing nothing.");
+        return;
+      }
+    }
+    await client.send(
+      new import_client_ssm3.DeleteParameterCommand({
+        Name: path
+      })
+    );
+    log("\u{1F44D}");
+  };
+};
+
+// src/bin/axiom.ts
+(0, import_yargs.default)(process.argv.slice(2)).env("AXIOM").scriptName("axiom").option("config", {
+  alias: "c",
+  string: true
+}).command(new Config()).command(new ParamsCommand()).strict().usage(
+  `
+Axiom - an AWS focused config cli
+
+USAGE:
+           $0 [options] <command>
+       `
+).demandCommand(1, "").alias("h", "help").argv;

package/dist/bin/axiom.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../chunk-D4DGV6KK.mjs";