@mux/cli 0.8.0 → 1.0.0-beta.1

package/src/command-bases/live-base.ts

@@ -1,35 +0,0 @@
-import { flags } from '@oclif/command';
-import { IFlag } from '@oclif/command/lib/flags';
-
-import CommandBase from './base';
-
-export default abstract class LiveCommandBase extends CommandBase {
-  static argsForSingleLiveStream = [
-    {
-      name: 'streamName',
-      description:
-        "the name (coupled with --reference-type) to look up in Mux to yield this livestream",
-      required: true,
-    },
-  ];
-
-  static flagsForSingleLiveStream: Record<string, IFlag<any>> = {
-    streamId: flags.string({
-      name: 'reference-type',
-      char: 't',
-      description: 'the type of the provided reference name',
-      options: ['stream-id'],
-      default: 'stream-id',
-    }),
-  }
-
-  protected getStreamId(flags: Record<string, any>, streamName: string): string {
-    switch (flags.streamId) {
-      case 'stream-id':
-        // just a pass-through
-        return streamName;
-    }
-
-    throw new Error("Could not derive a stream ID. Please pass one with --stream-id.");
-  }
-}

package/src/commands/assets/create.ts

@@ -1,74 +0,0 @@
-import * as chalk from 'chalk';
-import * as clipboard from 'clipboardy';
-import * as Listr from 'listr';
-
-import AssetCommandBase from '../../command-bases/asset-base';
-
-export default class AssetsCreate extends AssetCommandBase {
-  static description =
-    "Create a new asset in Mux using a file that's already available online";
-
-  static args = [
-    {
-      name: 'input',
-      description:
-        "input URL for the file you'd like to create this asset from",
-      required: true,
-    },
-  ];
-
-  async run() {
-    const { args, flags } = this.parse(AssetsCreate);
-    let assetBodyParams = {
-      input: args.input,
-      playback_policies: flags.private ? ['signed'] : ['public'],
-    };
-
-    const tasks = new Listr([
-      {
-        title: 'Creating Mux Asset',
-        task: async ctx => {
-          const asset = await this.Video.Assets.create(assetBodyParams);
-          ctx.asset = asset;
-        },
-      },
-      {
-        title: 'Waiting for asset to be playable',
-        task: async ctx => {
-          const asset = await this.pollAsset(ctx.asset.id);
-          ctx.asset = asset;
-        },
-      },
-    ]);
-
-    try {
-      const ctx = await tasks.run();
-      const playbackUrl = this.playbackUrl(ctx.asset);
-
-      if (!process.env.WSL_DISTRO_NAME) {
-        await clipboard.write(playbackUrl);
-      }
-
-      this.log(
-        chalk`
-  💫 {bold.blue Asset ready for your enjoyment!}
-
-  {bold.underline Playback URL}
-  ${playbackUrl}
-  `
-      );
-    } catch (err) {
-      console.log(
-        chalk.redBright('Error:') +
-        "\n\n" +
-        err
-      );
-
-      if (err instanceof Error) {
-        this.error(err);
-      } else {
-        throw err;
-      }
-    }
-  }
-}

package/src/commands/assets/upload.ts

@@ -1,192 +0,0 @@
-import { CreateUploadParams, Upload } from '@mux/mux-node';
-import { flags } from '@oclif/command';
-import * as chalk from 'chalk';
-import * as clipboard from 'clipboardy';
-import * as fs from 'fs-extra';
-import * as inquirer from 'inquirer';
-import * as Listr from 'listr';
-import * as path from 'path';
-import * as request from 'request';
-
-import AssetCommandBase, { AssetBaseFlags } from '../../command-bases/asset-base';
-
-export type AssetCreateFlags = AssetBaseFlags & {
-  filter: flags.IOptionFlag<string | undefined>;
-  concurrent: flags.IOptionFlag<number>;
-};
-
-export default class AssetsCreate extends AssetCommandBase {
-  static description = 'Create a new asset in Mux via a local file';
-
-  static args = [
-    {
-      name: 'path',
-      description: "local path for the file (or folder) you'd like to upload",
-      required: true,
-    },
-  ];
-
-  static flags: AssetCreateFlags = {
-    ...AssetCommandBase.flags,
-    filter: flags.string({
-      char: 'f',
-      description:
-        'regex that filters the selected destination if the provided path is a folder',
-    }),
-    concurrent: flags.integer({
-      char: 'c',
-      description: 'max number of files to upload at once',
-      default: 3,
-    }),
-    private: flags.boolean({
-      char: 'p',
-      default: false,
-    })
-  };
-
-  getFilePaths(filePath: string, filter = '') {
-    if (fs.lstatSync(filePath).isDirectory()) {
-      return fs.readdirSync(filePath).filter(file => file.match(filter));
-    }
-
-    return [filePath];
-  }
-
-  uploadFile(filePath: string, url: string) {
-    return new Promise((resolve, reject) => {
-      fs.createReadStream(path.resolve(process.cwd(), filePath)).pipe(
-        request
-          .put(url)
-          .on('response', resolve)
-          .on('error', reject)
-      );
-    });
-  }
-
-  pollUpload(uploadId: string): Promise<Upload> {
-    return new Promise((resolve, reject) => {
-      const poll = () =>
-        setTimeout(async () => {
-          try {
-            const upload = await this.Video.Uploads.get(uploadId);
-            if (upload.status === 'asset_created') {
-              return resolve(upload);
-            } else if (upload.status === 'errored') {
-              return reject(upload);
-            }
-
-            poll();
-          } catch (err) {
-            reject(err);
-          }
-        }, 500);
-
-      poll();
-    });
-  }
-
-  async run() {
-    const { args, flags } = this.parse(AssetsCreate);
-
-    let assetBodyParams: CreateUploadParams = {
-      new_asset_settings: {
-        playback_policy: flags.private ? ['signed'] : ['public'],
-      },
-    };
-
-    const regex = new RegExp(flags.filter || '', 'ig');
-    const files = this.getFilePaths(
-      path.resolve(process.cwd(), args.path)
-    ).filter(file => file.match(regex));
-
-    let prompt = { files };
-    if (files.length === 0) {
-      return this.log(
-        `We were unable to find any files. You might want to double check your path or make sure your filter isn't too strict`
-      );
-    } else if (files.length > 1) {
-      prompt = await inquirer.prompt([
-        {
-          type: 'checkbox',
-          name: 'files',
-          message: 'We found a few files! Do all of these look good?',
-          choices: files,
-          default: files,
-        },
-      ]);
-    }
-
-    const tasks = prompt.files.map((file: string) => ({
-      title: `${file}: getting direct upload URL`,
-      task: async (ctx: any, task: Listr.ListrTaskWrapper) => {
-        const upload = await this.Video.Uploads.create(assetBodyParams);
-
-        task.title = `${file}: uploading`;
-        await this.uploadFile(
-          path.resolve(process.cwd(), args.path, file),
-          upload.url
-        );
-
-        task.title = `${file}: waiting for asset to be playable`;
-        const { asset_id: assetId } = await this.pollUpload(upload.id);
-
-        if (!assetId) {
-          throw new Error(`Asset for upload '${upload.id}' failed to resolve.`);
-        }
-        const asset = await this.pollAsset(assetId);
-
-        const playbackUrl = this.playbackUrl(asset);
-        task.title = `${file}: ${playbackUrl}`;
-        ctx.assets = [
-          ...(ctx.assets || [['Filename', 'Asset ID', 'PlaybackURL']]),
-          [file, asset.id, playbackUrl],
-        ];
-      },
-    }));
-
-    // I hate this `any` here, but I'm running into a weird issue casting
-    // the `tasks` above to an array of `ListrTasks[]`.
-    try {
-      const finalCtx = await new Listr(tasks, {
-        concurrent: flags.concurrent,
-      }).run();
-
-      const tsv = finalCtx.assets
-        .map((row: string[]) => row.join('\t'))
-        .join('\n');
-      if (prompt.files.length > 1 && !process.env.WSL_DISTRO_NAME) {
-        await clipboard.write(tsv);
-
-        return this.log(
-          chalk`
-  📹 {bold.underline Assets ready for your enjoyment:}
-  ${tsv}
-
-  {blue (copied to your clipboard)}`
-        );
-      }
-
-      await clipboard.write(finalCtx.assets[1][2]);
-      return this.log(
-        chalk`
-  📹 {bold.underline Asset ready for your enjoyment:}
-  ${tsv}
-
-  {blue (since you only uploaded one asset, we just added the playback URL to your clipboard.)}`
-      );
-    } catch (err) {
-      // TODO: make this clearer / separate it out per video for more obvious debugging.
-      console.log(
-        chalk.redBright('Error:') +
-        "\n\n" +
-        err
-      );
-
-      if (err instanceof Error) {
-        this.error(err);
-      } else {
-        throw err;
-      }
-    }
-  }
-}

package/src/commands/init.ts

@@ -1,150 +0,0 @@
-import Mux from '@mux/mux-node';
-import { flags } from '@oclif/command';
-import * as Parser from '@oclif/parser';
-import * as chalk from 'chalk';
-import * as dotenv from 'dotenv';
-import * as fs from 'fs-extra';
-import * as inquirer from 'inquirer';
-import * as path from 'path';
-
-import MuxBase from '../command-bases/base';
-import { MuxCliConfigV1 } from '../config';
-
-export type InitFlags = {
-  force: Parser.flags.IBooleanFlag<boolean>;
-};
-
-export default class Init extends MuxBase {
-  static description = 'set up a user-level config';
-
-  static args = [
-    {
-      name: 'envFile',
-      required: false,
-      description: 'path to a Mux access token .env file',
-      parse: (input: string) => path.resolve(input),
-    },
-  ];
-
-  static flags: InitFlags = {
-    force: flags.boolean({
-      name: 'force',
-      char: 'f',
-      description: 'Will initialize a new file even if one already exists.',
-      default: false,
-    }),
-  };
-
-  Video: any;
-  JWT: any;
-
-  muxConfig: Partial<MuxCliConfigV1> = {};
-
-  async run() {
-    const { args, flags } = this.parse(Init);
-
-    let prompts: {
-      name: string;
-      message: string;
-      type: string;
-      default?: string;
-    }[] = [];
-
-    if (args.envFile) {
-      const envFile = path.resolve(args.envFile);
-      const env = dotenv.config({ path: envFile });
-      if (env.error) {
-        this.error(`Unable to load env file: ${envFile}`);
-      } else if (env.parsed) {
-        this.log(
-          chalk`Loaded your Mux .env file! Using token with id: {blue ${
-            env.parsed.MUX_TOKEN_ID
-          }}`
-        );
-        process.env.MUX_TOKEN_ID = env.parsed.MUX_TOKEN_ID;
-        process.env.MUX_TOKEN_SECRET = env.parsed.MUX_TOKEN_SECRET;
-      }
-    } else {
-      prompts = [
-        {
-          name: 'tokenId',
-          message: "What's your token ID?",
-          type: 'string',
-          default: process.env.MUX_TOKEN_ID,
-        },
-        {
-          name: 'tokenSecret',
-          message: "What's your token secret?",
-          type: 'password',
-          default: process.env.MUX_TOKEN_SECRET,
-        },
-      ];
-    }
-
-    if (!flags.force && (await fs.pathExists(this.configFile))) {
-      this.log(
-        chalk`{bold.underline.red You are attempting to initialize with an existing configuration file!} If this is intentional, please pass {bold.yellow --force}.`
-      );
-      process.exit(1);
-    }
-
-    const signingKeyPrompt = {
-      name: 'createSigningKey',
-      message:
-        'Do you want to go ahead and set up a Signing Key? This is used to create tokens for signed playback policies.',
-      type: 'confirm',
-    };
-
-    if (process.env.MUX_SIGNING_KEY || process.env.MUX_PRIVATE_KEY) {
-      signingKeyPrompt.message =
-        'Looks like you already have a signing key configured. Would you like to create a new one?';
-    }
-
-    prompts = [...prompts, signingKeyPrompt];
-
-    const answers = await inquirer.prompt(prompts);
-    let { createSigningKey, tokenId, tokenSecret }: any = answers;
-
-    // If the token was loaded from an env file they'll already be set in the appropriate environment variables and
-    // the prompts themselves will be null.
-    this.muxConfig.configVersion = 1;
-    this.muxConfig.tokenId = process.env.MUX_TOKEN_ID = tokenId || process.env.MUX_TOKEN_ID;
-    this.muxConfig.tokenSecret = process.env.MUX_TOKEN_SECRET = tokenSecret || process.env.MUX_TOKEN_SECRET;
-
-    if (createSigningKey) {
-      const { Video } = new Mux();
-      try {
-        // this is not great; we need to also update mux-node for this call
-        // but that's a bigger can of worms. We'll come back to this one.
-        // @ts-ignore
-        const { id, private_key } = await Video.SigningKeys.create();
-        this.muxConfig.signingKeyId = process.env.MUX_SIGNING_KEY = id;
-        this.muxConfig.signingKeySecret = process.env.MUX_PRIVATE_KEY = private_key;
-      } catch {
-        this.error(
-          "Couldn't create a signing key pair! Are you sure your token credentials were right?"
-        );
-      }
-    }
-
-    try {
-      await fs.ensureDir(this.config.configDir);
-      await fs.writeFile(
-        this.configFile,
-        JSON.stringify(this.muxConfig),
-        'utf8'
-      );
-    } catch (err) {
-      // TODO: improve error handling type safety here
-      if (err instanceof Error) {
-        this.error(err);
-      } else {
-        throw err;
-      }
-    }
-
-    this.log(
-      chalk`{bold.underline Configuration written to:} ${this.configFile}`
-    );
-  }
-}

package/src/commands/live/complete.ts

@@ -1,63 +0,0 @@
-import * as Listr from 'listr';
-import { flags } from '@oclif/command';
-import { IFlag } from '@oclif/command/lib/flags';
-
-import LiveCommandBase from '../../command-bases/live-base';
-import chalk = require('chalk');
-
-export default class LiveComplete extends LiveCommandBase {
-  static description =
-    "Signal to Mux that a live stream has concluded and should be closed.";
-
-  static args = [
-    ...LiveCommandBase.argsForSingleLiveStream,
-  ];
-
-  static flags: Record<string, IFlag<any>> = {
-    ...LiveCommandBase.flagsForSingleLiveStream,
-    disableAfterCompletion: flags.boolean({
-      name: 'disable-after-completion',
-      char: 'd',
-      description: 'If set, disables the stream upon completion.',
-      default: false,
-    }),
-  }
-
-  async run() {
-    const { args, flags } = this.parse(LiveComplete);
-    const streamId: string = this.getStreamId(flags, args.streamName);
-
-    try {
-      await (new Listr([
-        {
-          title: `Signaling completion of '${streamId}'`,
-          task: async (ctx, task) => {
-            await this.Video.LiveStreams.signalComplete(streamId),
-            task.title = `${task.title} (OK)`;
-          },
-        },
-        {
-          title: `Disabling '${streamId}'`,
-          enabled: () => flags.disableAfterCompletion,
-          task: async (ctx, task) => {
-            await this.Video.LiveStreams.disable(streamId);
-            task.title = `${task.title} (OK)`;
-          },
-        },
-      ], {}).run());
-    } catch (err) {
-      // TODO: make this clearer
-      console.log(
-        chalk.redBright('Error:') +
-        "\n\n" +
-        err
-      );
-
-      if (err instanceof Error) {
-        this.error(err);
-      } else {
-        throw err;
-      }
-    }
-  }
-}

package/src/commands/live/disable.ts

@@ -1,47 +0,0 @@
-import * as Listr from 'listr';
-
-import LiveCommandBase from '../../command-bases/live-base';
-import chalk = require('chalk');
-
-export default class LiveDisable extends LiveCommandBase {
-  static description =
-    "Disables a live stream and prevents encoders from streaming to it.";
-
-  static args = [
-    ...LiveCommandBase.argsForSingleLiveStream,
-  ];
-
-  static flags = {
-    ...LiveCommandBase.flagsForSingleLiveStream,
-  }
-
-  async run() {
-    const { args, flags } = this.parse(LiveDisable);
-    const streamId: string = this.getStreamId(flags, args.streamName);
-
-    try {
-      await (new Listr([
-        {
-          title: `Disabling '${streamId}'`,
-          task: async (ctx, task) => {
-            await this.Video.LiveStreams.disable(streamId);
-            task.title = `${task.title} (OK)`;
-          },
-        },
-      ], {}).run());
-    } catch (err) {
-      // TODO: make this clearer
-      console.log(
-        chalk.redBright('Error:') +
-        "\n\n" +
-        err
-      );
-
-      if (err instanceof Error) {
-        this.error(err);
-      } else {
-        throw err;
-      }
-    }
-  }
-}

package/src/commands/live/enable.ts

@@ -1,47 +0,0 @@
-import * as Listr from 'listr';
-
-import LiveCommandBase from '../../command-bases/live-base';
-import chalk = require('chalk');
-
-export default class LiveEnable extends LiveCommandBase {
-  static description =
-    "Enables a live stream, allowing encoders to streaming to it.";
-
-  static args = [
-    ...LiveCommandBase.argsForSingleLiveStream,
-  ];
-
-  static flags = {
-    ...LiveCommandBase.flagsForSingleLiveStream,
-  }
-
-  async run() {
-    const { args, flags } = this.parse(LiveEnable);
-    const streamId: string = this.getStreamId(flags, args.streamName);
-
-    try {
-      await (new Listr([
-        {
-          title: `Enabling '${streamId}'`,
-          task: async (ctx, task) => {
-            await this.Video.LiveStreams.enable(streamId);
-            task.title = `${task.title} (OK)`;
-          },
-        },
-      ], {}).run());
-    } catch (err) {
-      // TODO: make this clearer
-      console.log(
-        chalk.redBright('Error:') +
-        "\n\n" +
-        err
-      );
-
-      if (err instanceof Error) {
-        this.error(err);
-      } else {
-        throw err;
-      }
-    }
-  }
-}

package/src/commands/sign.ts

@@ -1,76 +0,0 @@
-import { flags } from '@oclif/command';
-// this is a load-bearing unused import due to oclif type issues
-import { IOptionFlag, IBooleanFlag } from '@oclif/parser/lib/flags';
-import * as chalk from 'chalk';
-import * as clipboard from 'clipboardy';
-
-import MuxBase from '../command-bases/base';
-
-export default class Sign extends MuxBase {
-  static description = 'Creates a new signed URL token for a playback ID';
-
-  static args = [
-    {
-      name: 'playback-id',
-      description: 'Playback ID to create a signed URL token for.',
-      required: true,
-    },
-  ];
-
-  static flags: any = {
-    expiresIn: flags.string({
-      char: 'e',
-      description: 'How long the signature is valid for. If no unit is specified, milliseconds is assumed.',
-      default: '7d',
-    }),
-    type: flags.string({
-      char: 't',
-      description: 'What type of token this signature is for.',
-      default: 'video',
-      options: ['video', 'thumbnail', 'gif', 'storyboard'],
-    }),
-    raw: flags.boolean({
-      char: 'r',
-      description: 'If set, emits only the URL+JWT. Defaults to true for non-TTY.',
-      default: !process.stdin.isTTY,
-    }),
-  };
-
-  async run() {
-    const parsed = this.parse(Sign);
-    const args = parsed.args;
-    const flags = parsed.flags as any;
-
-    const playbackId = args['playback-id'];
-
-    const options = {
-      expiration: flags.expiresIn,
-      type: flags.type as any, // TODO: is better checked in SDK, but this is ugly.
-      keyId: this.MuxConfig.signingKeyId,
-      keySecret: this.MuxConfig.signingKeySecret,
-    };
-    const key = this.JWT.sign(playbackId, options);
-    const url = `https://stream.mux.com/${playbackId}.m3u8?token=${key}`;
-
-    if (flags.raw) {
-      console.log(url);
-    } else {
-      this.log(
-        chalk`
-🔑 {bold.underline Your Mux Signed Token}
-{blue ${key}}
-
-🌏 {bold.underline Full URL}
-{green ${url}}
-  `
-      );
-
-      try {
-        await clipboard.write(url);
-        this.log(`👉 Copied Full URL to your system clipboard`);
-      } catch {
-        this.error('Unable to copy full url automatically');
-      }
-    }
-  }
-}