module.exports = function (argv: string[]): void {
	program
		.version(pkg.version);

	program
		.command('ls')
		.description('Lists all the files that will be published')
		.action(() => main(ls()));

	program
		.command('package')
		.description('Packages an extension')
		.option('-o, --out [path]', 'Location of the package')
		.option('--baseContentUrl [url]', 'Prepend all relative links in README.md with this url.')
		.option('--baseImagesUrl [url]', 'Prepend all relative image links in README.md with this url.')
		.action(({ out, baseContentUrl, baseImagesUrl }) => main(packageCommand({ packagePath: out, baseContentUrl, baseImagesUrl })));

	program
		.command('publish [<version>]')
		.description('Publishes an extension')
		.option('-p, --pat <token>', 'Personal Access Token')
		.option('--packagePath [path]', 'Publish the VSIX package located at the specified path.')
		.option('--baseContentUrl [url]', 'Prepend all relative links in README.md with this url.')
		.option('--baseImagesUrl [url]', 'Prepend all relative image links in README.md with this url.')
		.action((version, { pat, packagePath, baseContentUrl, baseImagesUrl }) => main(publish({ pat, version, packagePath, baseContentUrl, baseImagesUrl })));

	program
		.command('unpublish [<extensionid>]')
		.description('Unpublishes an extension. Example extension id: microsoft.csharp.')
		.option('-p, --pat <token>', 'Personal Access Token')
		.action((id, { pat }) => main(unpublish({ id, pat })));

	program
		.command('list <publisher>')
		.description('Lists all extensions published by the given publisher')
		.action(publisher => main(list(publisher)));

	program
		.command('ls-publishers')
		.description('List all known publishers')
		.action(() => main(listPublishers()));

	program
		.command('create-publisher <publisher>')
		.description('Creates a new publisher')
		.action(publisher => main(createPublisher(publisher)));

	program
		.command('delete-publisher <publisher>')
		.description('Deletes a publisher')
		.action(publisher => main(deletePublisher(publisher)));

	program
		.command('login <publisher>')
		.description('Add a publisher to the known publishers list')
		.action(name => main(loginPublisher(name)));

	program
		.command('logout <publisher>')
		.description('Remove a publisher from the known publishers list')
		.action(name => main(logoutPublisher(name)));

	program
		.command('*')
		.action(() => program.help());

	program.parse(argv);

	if (process.argv.length <= 2) {
		program.help();
	}
};

  if (typeof(path) === 'undefined' || typeof(val) === 'undefined') {
    // tslint:disable-next-line
    console.warn('Invalid format for invalid config. Correct is -> jsonpath=value');
    return opts;
  }
  try {
    jp.parse(path);
  } catch (e) {
    // tslint:disable-next-line
    console.warn('JSONPath is invalid', e);
  }
  opts.push({ path, val });
  return opts;
};

program
  .version(packageJson)
  .option('-n, --net <network>', 'network: mainnet, testnet', 'mainnet')
  .option('-p, --port <port>', 'listening port number')
  .option('-a, --address <ip>', 'listening host name or ip')
  .option('-x, --peers [peers...]', 'peers list')
  .option('-l, --log <level>', 'log level')
  .option('-s, --snapshot [round]', 'verify snapshot')
  .option('-c, --config <path>', 'custom config path')
  .option('-e, --extra-config <path>', 'partial override config path')
  .option('-o, --override-config <item>', 'Override single config item', overrideFn)
  .option('-C --override-constant <item>', 'Override constants for testing purposes', overrideFn)
  .parse(process.argv);

// tslint:disable-next-line
const genesisBlock: SignedAndChainedBlockType = require(`../etc/${program.net}/genesisBlock.json`);

/// <reference path="../typings/index.d.ts" />

// Startup script for running BST
import {BespokeServer} from "../lib/server/bespoke-server";
import * as program from "commander";
import {Global} from "../lib/core/global";

program.version(Global.version());

program
    .command("start <webhookPort> <nodePort>")
    .description("Starts the BST server")
    .action(function (nodeID: string, port: number, options: any) {
        let webhookPort: number = parseInt(process.argv[3]);
        let serverPort: number = parseInt(process.argv[4]);
        let bespokeServer = new BespokeServer(webhookPort, serverPort);
        bespokeServer.start();
    });

program.parse(process.argv);

import { config } from 'dotenv';
import fetch from 'node-fetch';
import FormData from 'form-data';
import program from 'commander';
import readline from 'readline';

import { core } from 'botframework-webchat';
import { DirectLine } from './directLine';

const { createStore, postActivity, startConnection } = core;

config();

const CRLF = '\r\n';

program
  .version('1.0.0');

function main() {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });

  rl.setPrompt('> ');
  rl.pause();

  const store = createStore(
    store => next => action => {
      const { payload, type } = action;

      if (type === 'DIRECT_LINE/RECEIVE_ACTIVITY') {

var chalk = require('chalk');
var packageJson = require('../package.json');
import * as moment from 'moment';
import Promise = require('bluebird');

import {
    GHRepository,
    IssueType,
    IssueState,
    IssueActivity,
    IssueActivityFilter,
    FilterCollection
    } from 'gh-issues-api';


commander.version(packageJson.version)
         .usage('[options] <OWNER> <REPOSITORY>')
         .option('-u, --user [user]', 'Github username (used to authenticate the request and raise API calls rate limits)')
         .option('-p, --password [password/token]', 'Github password or security token (used to authenticate the request and raise API calls rate limits)')
         .option('-d, --days [days]', 'Days since the last time the issue was updated (7 by default)')
         .parse(process.argv);

if (commander.args.length < 2) {
    commander.help();
    process.exit(-1);
}

var owner = commander.args[0];
var repository = commander.args[1];
var user = commander.user;
var token = commander.password;

export default function CliImport() {
    let err;
    let program = require('commander');
    let colors = require('colors');
    let pkg = require('../package.json');
    let util = require('util');

    program.version(pkg.version)
        .option('-c, --collection <collection>', 'The Power BI workspace collection')
        .option('-w, --workspace <workspaceId>', 'The Power BI workspace')
        .option('-k, --accessKey <accessKey>', 'The Power BI workspace collection access key')
        .option('-n, --displayName <displayName>', 'The dataset display name')
        .option('-f, --file <file>', 'The PBIX file to upload')
        .option('-o, --overwrite [overwrite]', 'Whether to overwrite a dataset with the same name.  Default is false')
        .option('-b --baseUri [baseUri]', 'The base uri to connect to');

    program.on('--help', function () {
        console.log('  Examples:');
        console.log('');
        console.log('    $ powerbi import -c <collection> -k <accessKey> -w <workspace> -f <file>');
    });

    program.parse(process.argv);
    let settings = config.merge(program);

    if (process.argv.length === 2) {
        program.help();
    } else {
        try {
            let options: powerbi.ImportFileOptions = {};
            let token = powerbi.PowerBIToken.createDevToken(settings.collection, settings.workspace);
            let credentials = new msrest.TokenCredentials(token.generate(settings.accessKey), 'AppToken');
            let client = new powerbi.PowerBIClient(credentials, settings.baseUri, null);

            if (!_.isUndefined(settings.overwrite) && settings.overwrite) {
                options.nameConflict = 'Overwrite';
            }

            options.datasetDisplayName = settings.displayName;

            if (!fs.existsSync(settings.file)) {
                throw new Error(util.format('File "%s" not found', settings.file));
            }

            cli.print('Importing %s to workspace: %s', settings.file, settings.workspace);

            client.imports.uploadFile(settings.collection, settings.workspace, settings.file, options, (err, result, request, response) => {
                if (err) {
                    return cli.error(err);
                }

                let importResult: powerbi.ImportModel = result;

                cli.print('File uploaded successfully');
                cli.print('Import ID: %s', importResult.id);

                checkImportState(client, importResult, (importStateErr, importStateResult) => {
                    if (importStateErr) {
                        return cli.print(importStateErr);
                    }

                    cli.print('Import succeeded');
                });
            });
        } catch (err) {
            cli.error(err);
        }
    }

    /**
     * Checks the import state of the requested import id
     */
    function checkImportState(client: powerbi.PowerBIClient, importResult: powerbi.ImportModel, callback) {
        client.imports.getImportById(settings.collection, settings.workspace, importResult.id, (err, result) => {
            importResult = result;
            cli.print('Checking import state: %s', importResult.importState);

            if (importResult.importState === 'Succeeded' || importResult.importState === 'Failed') {
                callback(null, importResult);
            } else {
                setTimeout(() => {
                    checkImportState(client, importResult, callback);
                }, 500);
            }
        });
    }
}

        } else {
            list.push(pathJoin(path, file));
        }
    });

    return list;
}

// Main -------------------------------------------------------------------

// Set the application root so that configuration files can be located
let programAppRoot = resolve(__dirname, "..");
let programDeployConfigFile = pathJoin(programAppRoot, "deploy.json");

// Configure the script
program.version("0.0.1")
       .description("Helper script to perform a deployment of the built templates")
       .option("-c, --config [config]", "Configuration file to use", programDeployConfigFile);

// Add command to upload the files to blob storage
program.command("upload <subscription>")
       .description("Upload files to blob storage. Storage account and container are taken from configuration or overridden with options")
       .option("-s, --saname [name]", "Storage account name")
       .option("-n, --container [container]", "Name of container within specified storage")
       .option("-a, --authfile [authfilename]", "Path to Azure credentials file", pathJoin(homedir(), ".azure", "credentials"))
       .option("-G, --groupname [sagroupname]", "Name of the resource group that contains the storage account")
       .action((subscription, options) => {
           upload(parseConfig(programAppRoot, program.config, options, "upload"), subscription);
       });

// Add command to manage resource group and deploy the template

    convertBlackWhite: new ConvertBlackWhite(),
    // pixelSortBlackVert: require("./lib/pixel-sort-black-vert.js"),
    sortBrightness: new SortBrightness(),
    // pixelSortGreenChannel: require("./lib/pixel-sort-green-channel.js"),
    // pixelSortRedChannel: require("./lib/pixel-sort-red-channel.js"),
    // pixelSortBlueChannel: require("./lib/pixel-sort-blue-channel.js"),
    redBlueSwitch: new RedBlueSwitch(),
    redGreenSwitch: new RedGreenSwitch(),
    blueGreenSwitch: new BlueGreenSwitch(),
    sortBlack: new SortBlack(),
    sortBlackHi: new SortBlackHi(),
    sortBlackHoriz: new SortBlackHoriz(),
    sortWhite: new SortWhite()
};

commander
    .version("0.0.1")
    .option("-f, --file <filename>", "Path to file to sort. Will sort all png if this is a directory")
    .option("-t, --transformation <transformation...>", "Transformations to apply to image. To do multiple transformations, separate with commas")
    .option("--all", "Apply all transforms to the given file");

commander.on("--help", function() {
    console.log("  Valid Transformations:");
    console.log("");
    for (const [key, value] of Object.entries(allTransforms)) {
        console.log(`    ${key}: ${value.description()}`);
    }
});

commander.parse(process.argv);

if (!commander.file || (!commander.all && !commander.transformation)) {

import * as program from "commander";
import * as fs from "fs";
import * as goita from "goita-core";
const packageJson = JSON.parse(fs.readFileSync(__dirname + "/../package.json").toString());

const command = program.version(packageJson.version)
    .option("-l, --limit [limit]", "search limit(leaves)", 10000)
    .parse(process.argv);

const solver = new goita.Solver();

for (const a of command.args) {
    const evalMoves = solver.solve(a);
    if (evalMoves.length > 0) {
        process.stdout.write("Solve result for:\n");
        process.stdout.write(a + "\n");
        for (const m of evalMoves) {
            const result = m.move.toOpenString() + "(" + m.move.toOpenTextString() + "), score:" + m.score + ", trailing moves: " + m.history.replace(a + ",", "");
            process.stdout.write(result + "\n");
        }
    } else {
        process.stdout.write("cannot evaluate moves\n");
    }
}

process.exit(0);

/// <reference path="typings/tsd.d.ts" />
import install = require("./index-install");
import links = require("./index-links");
import npmi = require("./index-npmi");

var program = require('commander');
var pkginfo = require('pkginfo')(module);
var path = require("path");

program
  .version(module.exports.version || "unknown")
  .command("install", "Install MyKoop from fresh")
  .command("links", "Update npm link & tsd link for local development")
  .command("npmi", "Runs npm install on all repositories")
  .parse(process.argv);