@oclif/core 2.0.0-beta.3 → 2.0.0-beta.4

package/lib/flags.js

@@ -1,44 +1,86 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.help = exports.version = exports.enum = exports._enum = exports.custom = exports.option = exports.build = exports.string = exports.file = exports.directory = exports.url = exports.integer = exports.boolean = void 0;
-const parser_1 = require("./parser");
+exports.help = exports.version = exports.string = exports.url = exports.file = exports.directory = exports.integer = exports.boolean = exports.custom = void 0;
+const url_1 = require("url");
 const help_1 = require("./help");
-var parser_2 = require("./parser");
-Object.defineProperty(exports, "boolean", { enumerable: true, get: function () { return parser_2.boolean; } });
-Object.defineProperty(exports, "integer", { enumerable: true, get: function () { return parser_2.integer; } });
-Object.defineProperty(exports, "url", { enumerable: true, get: function () { return parser_2.url; } });
-Object.defineProperty(exports, "directory", { enumerable: true, get: function () { return parser_2.directory; } });
-Object.defineProperty(exports, "file", { enumerable: true, get: function () { return parser_2.file; } });
-Object.defineProperty(exports, "string", { enumerable: true, get: function () { return parser_2.string; } });
-Object.defineProperty(exports, "build", { enumerable: true, get: function () { return parser_2.build; } });
-Object.defineProperty(exports, "option", { enumerable: true, get: function () { return parser_2.option; } });
-Object.defineProperty(exports, "custom", { enumerable: true, get: function () { return parser_2.custom; } });
-function _enum(opts) {
-    return (0, parser_1.custom)({
-        async parse(input) {
-            if (!opts.options.includes(input))
-                throw new Error(`Expected --${this.name}=${input} to be one of: ${opts.options.join(', ')}`);
-            return input;
-        },
-        helpValue: `(${opts.options.join('|')})`,
-        ...opts,
-    })();
+const util_1 = require("./util");
+function custom(defaults) {
+    return (options = {}) => {
+        return {
+            parse: async (input, _ctx, _opts) => input,
+            ...defaults,
+            ...options,
+            input: [],
+            multiple: Boolean(options.multiple === undefined ? defaults.multiple : options.multiple),
+            type: 'option',
+        };
+    };
+}
+exports.custom = custom;
+function boolean(options = {}) {
+    return {
+        parse: async (b, _) => b,
+        ...options,
+        allowNo: Boolean(options.allowNo),
+        type: 'boolean',
+    };
 }
-exports._enum = _enum;
-exports.enum = _enum;
+exports.boolean = boolean;
+exports.integer = custom({
+    parse: async (input, _, opts) => {
+        if (!/^-?\d+$/.test(input))
+            throw new Error(`Expected an integer but received: ${input}`);
+        const num = Number.parseInt(input, 10);
+        if (opts.min !== undefined && num < opts.min)
+            throw new Error(`Expected an integer greater than or equal to ${opts.min} but received: ${input}`);
+        if (opts.max !== undefined && num > opts.max)
+            throw new Error(`Expected an integer less than or equal to ${opts.max} but received: ${input}`);
+        return num;
+    },
+});
+exports.directory = custom({
+    parse: async (input, _, opts) => {
+        if (opts.exists)
+            return (0, util_1.dirExists)(input);
+        return input;
+    },
+});
+exports.file = custom({
+    parse: async (input, _, opts) => {
+        if (opts.exists)
+            return (0, util_1.fileExists)(input);
+        return input;
+    },
+});
+/**
+ * Initializes a string as a URL. Throws an error
+ * if the string is not a valid URL.
+ */
+exports.url = custom({
+    parse: async (input) => {
+        try {
+            return new url_1.URL(input);
+        }
+        catch {
+            throw new Error(`Expected a valid url but received: ${input}`);
+        }
+    },
+});
+const stringFlag = custom({});
+exports.string = stringFlag;
 const version = (opts = {}) => {
-    return (0, parser_1.boolean)({
+    return boolean({
         description: 'Show CLI version.',
         ...opts,
-        parse: async (_, cmd) => {
-            cmd.log(cmd.config.userAgent);
-            cmd.exit(0);
+        parse: async (_, ctx) => {
+            ctx.log(ctx.config.userAgent);
+            ctx.exit(0);
         },
     });
 };
 exports.version = version;
 const help = (opts = {}) => {
-    return (0, parser_1.boolean)({
+    return boolean({
         description: 'Show CLI help.',
         ...opts,
         parse: async (_, cmd) => {

package/lib/help/command.d.ts

@@ -1,16 +1,16 @@
 import * as Interfaces from '../interfaces';
-import { Example } from '../interfaces/command';
 import { HelpFormatter, HelpSectionRenderer } from './formatter';
+import { Command } from '../command';
 export declare class CommandHelp extends HelpFormatter {
-    command: Interfaces.Command;
+    command: Command.Class | Command.Loadable | Command.Cached;
     config: Interfaces.Config;
     opts: Interfaces.HelpOptions;
-    constructor(command: Interfaces.Command, config: Interfaces.Config, opts: Interfaces.HelpOptions);
+    constructor(command: Command.Class | Command.Loadable | Command.Cached, config: Interfaces.Config, opts: Interfaces.HelpOptions);
     generate(): string;
-    protected groupFlags(flags: Interfaces.Command.Flag[]): {
-        mainFlags: Interfaces.Command.Flag[];
+    protected groupFlags(flags: Array<Command.Flag.Any>): {
+        mainFlags: Array<Command.Flag.Any>;
         flagGroups: {
-            [index: string]: Interfaces.Command.Flag[];
+            [name: string]: Array<Command.Flag.Any>;
         };
     };
     protected sections(): Array<{
@@ -21,11 +21,11 @@ export declare class CommandHelp extends HelpFormatter {
     protected defaultUsage(): string;
     protected description(): string | undefined;
     protected aliases(aliases: string[] | undefined): string | undefined;
-    protected examples(examples: Example[] | undefined | string): string | undefined;
-    protected args(args: Interfaces.Command['args']): [string, string | undefined][] | undefined;
-    protected arg(arg: Interfaces.Command['args'][0]): string;
-    protected flagHelpLabel(flag: Interfaces.Command.Flag, showOptions?: boolean): string;
-    protected flags(flags: Interfaces.Command.Flag[]): [string, string | undefined][] | undefined;
-    protected flagsDescriptions(flags: Interfaces.Command.Flag[]): string | undefined;
+    protected examples(examples: Command.Example[] | undefined | string): string | undefined;
+    protected args(args: Command.Arg.Any[]): [string, string | undefined][] | undefined;
+    protected arg(arg: Command.Arg.Any): string;
+    protected flagHelpLabel(flag: Command.Flag.Any, showOptions?: boolean): string;
+    protected flags(flags: Array<Command.Flag.Any>): [string, string | undefined][] | undefined;
+    protected flagsDescriptions(flags: Array<Command.Flag.Any>): string | undefined;
 }
 export default CommandHelp;

package/lib/help/command.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandHelp = void 0;
-const Chalk = require("chalk");
+const chalk = require("chalk");
 const stripAnsi = require("strip-ansi");
 const util_1 = require("../util");
 const formatter_1 = require("./formatter");
@@ -10,11 +10,11 @@ const docopts_1 = require("./docopts");
 // written on any platform, that may use \r\n or \n, will be
 // split on any platform, not just the os specific EOL at runtime.
 const POSSIBLE_LINE_FEED = /\r\n|\n/;
-const { underline, } = Chalk;
-let { dim, } = Chalk;
+const { underline, } = chalk;
+let { dim, } = chalk;
 if (process.env.ConEmuANSI === 'ON') {
     // eslint-disable-next-line unicorn/consistent-destructuring
-    dim = Chalk.gray;
+    dim = chalk.gray;
 }
 class CommandHelp extends formatter_1.HelpFormatter {
     constructor(command, config, opts) {
@@ -31,7 +31,7 @@ class CommandHelp extends formatter_1.HelpFormatter {
             v.name = k;
             return v;
         }), f => [!f.char, f.char, f.name]);
-        const args = (cmd.args || []).filter(a => !a.hidden);
+        const args = Object.values(cmd.args ?? {}).filter(a => !a.hidden);
         const output = (0, util_1.compact)(this.sections().map(({ header, generate }) => {
             const body = generate({ cmd, flags, args }, header);
             // Generate can return a list of sections
@@ -128,7 +128,7 @@ class CommandHelp extends formatter_1.HelpFormatter {
         }
         return (0, util_1.compact)([
             this.command.id,
-            this.command.args.filter(a => !a.hidden).map(a => this.arg(a)).join(' '),
+            Object.values(this.command.args ?? {})?.filter(a => !a.hidden).map(a => this.arg(a)).join(' '),
         ]).join(' ');
     }
     description() {

package/lib/help/docopts.d.ts

@@ -1,4 +1,4 @@
-import { Interfaces } from '..';
+import { Command } from '../command';
 /**
  * DocOpts - See http://docopt.org/.
  *
@@ -59,8 +59,8 @@ export declare class DocOpts {
     private cmd;
     private flagMap;
     private flagList;
-    constructor(cmd: Interfaces.Command);
-    static generate(cmd: Interfaces.Command): string;
+    constructor(cmd: Command.Class | Command.Loadable | Command.Cached);
+    static generate(cmd: Command.Class | Command.Loadable | Command.Cached): string;
     toString(): string;
     private groupFlagElements;
     private combineElementsToFlag;

package/lib/help/docopts.js

@@ -75,7 +75,7 @@ class DocOpts {
     toString() {
         const opts = this.cmd.id === '.' || this.cmd.id === '' ? [] : ['<%= command.id %>'];
         if (this.cmd.args) {
-            const a = this.cmd.args?.map(arg => `[${arg.name.toUpperCase()}]`) || [];
+            const a = Object.values(this.cmd.args ?? {}).map(arg => `[${arg.name.toUpperCase()}]`) || [];
             opts.push(...a);
         }
         try {
@@ -140,8 +140,7 @@ class DocOpts {
         // We handled this flag, don't handle it again
         delete this.flagMap[flagName];
     }
-    // eslint-disable-next-line default-param-last
-    generateElements(elementMap = {}, flagGroups) {
+    generateElements(elementMap = {}, flagGroups = []) {
         const elementStrs = [];
         for (const flag of flagGroups) {
             let type = '';

package/lib/help/formatter.d.ts

@@ -1,3 +1,4 @@
+import { Command } from '../command';
 import * as Interfaces from '../interfaces';
 export type HelpSectionKeyValueTable = {
     name: string;
@@ -8,9 +9,9 @@ export type HelpSection = {
     body: string | HelpSectionKeyValueTable | [string, string | undefined][] | undefined;
 } | undefined;
 export type HelpSectionRenderer = (data: {
-    cmd: Interfaces.Command;
-    flags: Interfaces.Command.Flag[];
-    args: Interfaces.Command.Arg[];
+    cmd: Command.Class | Command.Loadable | Command.Cached;
+    flags: Command.Flag.Any[];
+    args: Command.Arg.Any[];
 }, header: string) => HelpSection | HelpSection[] | string | undefined;
 export declare class HelpFormatter {
     indentSpacing: number;

package/lib/help/index.d.ts

@@ -1,6 +1,7 @@
 import * as Interfaces from '../interfaces';
 import CommandHelp from './command';
 import { HelpFormatter } from './formatter';
+import { Command } from '../command';
 export { CommandHelp } from './command';
 export { standardizeIDFromArgv, loadHelpClass, getHelpFlagAdditions, normalizeArgv } from './util';
 export declare abstract class HelpBase extends HelpFormatter {
@@ -15,31 +16,26 @@ export declare abstract class HelpBase extends HelpFormatter {
      * @param command
      * @param topics
      */
-    abstract showCommandHelp(command: Interfaces.Command, topics: Interfaces.Topic[]): Promise<void>;
+    abstract showCommandHelp(command: Command.Class, topics: Interfaces.Topic[]): Promise<void>;
 }
 export declare class Help extends HelpBase {
     protected CommandHelpClass: typeof CommandHelp;
     private get _topics();
-    protected get sortedCommands(): Interfaces.Command.Loadable[];
+    protected get sortedCommands(): Command.Loadable[];
     protected get sortedTopics(): Interfaces.Topic[];
     constructor(config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>);
     showHelp(argv: string[]): Promise<void>;
-    showCommandHelp(command: Interfaces.Command): Promise<void>;
+    showCommandHelp(command: Command.Class | Command.Loadable | Command.Cached): Promise<void>;
     protected showRootHelp(): Promise<void>;
     protected showTopicHelp(topic: Interfaces.Topic): Promise<void>;
     protected formatRoot(): string;
-    protected formatCommand(command: Interfaces.Command): string;
-    protected getCommandHelpClass(command: Interfaces.Command): CommandHelp;
-    protected formatCommands(commands: Interfaces.Command[]): string;
-    protected summary(c: Interfaces.Command): string | undefined;
-    protected description(c: Interfaces.Command): string;
+    protected formatCommand(command: Command.Class | Command.Loadable | Command.Cached): string;
+    protected getCommandHelpClass(command: Command.Class | Command.Loadable | Command.Cached): CommandHelp;
+    protected formatCommands(commands: Array<Command.Class | Command.Loadable | Command.Cached>): string;
+    protected summary(c: Command.Class | Command.Loadable | Command.Cached): string | undefined;
+    protected description(c: Command.Class | Command.Loadable | Command.Cached): string;
     protected formatTopic(topic: Interfaces.Topic): string;
     protected formatTopics(topics: Interfaces.Topic[]): string;
-    /**
-     * @deprecated used for readme generation
-     * @param {object} command The command to generate readme help for
-     * @return {string} the readme help string for the given command
-     */
-    protected command(command: Interfaces.Command): string;
+    protected command(command: Command.Class): string;
     protected log(...args: string[]): void;
 }

package/lib/help/index.js

@@ -264,11 +264,6 @@ class Help extends HelpBase {
         });
         return this.section('TOPICS', body);
     }
-    /**
-     * @deprecated used for readme generation
-     * @param {object} command The command to generate readme help for
-     * @return {string} the readme help string for the given command
-     */
     command(command) {
         return this.formatCommand(command);
     }

package/lib/help/util.d.ts

@@ -1,11 +1,11 @@
-import { Config as IConfig, HelpOptions } from '../interfaces';
+import * as ejs from 'ejs';
+import { Config as IConfig, HelpOptions, Deprecation } from '../interfaces';
 import { HelpBase } from '.';
-import { Deprecation } from '../interfaces/parser';
 interface HelpBaseDerived {
     new (config: IConfig, opts?: Partial<HelpOptions>): HelpBase;
 }
 export declare function loadHelpClass(config: IConfig): Promise<HelpBaseDerived>;
-export declare function template(context: any): (t: string) => string;
+export declare function template(context: ejs.Data): (t: string) => string;
 export declare function toStandardizedId(commandID: string, config: IConfig): string;
 export declare function toConfiguredId(commandID: string, config: IConfig): string;
 export declare function standardizeIDFromArgv(argv: string[], config: IConfig): string[];

package/lib/help/util.js

@@ -45,7 +45,7 @@ function collateSpacedCmdIDFromArgs(argv, config) {
             if (!id)
                 return false;
             const cmd = config.findCommand(id);
-            return Boolean(cmd && (cmd.strict === false || cmd.args?.length > 0));
+            return Boolean(cmd && (cmd.strict === false || Object.keys(cmd.args ?? {}).length > 0));
         };
         for (const arg of argv) {
             if (idPresent(finalizeId(arg)))

package/lib/index.d.ts

@@ -1,15 +1,16 @@
-import Command from './command';
-import { run } from './main';
+import { Command } from './command';
+import { run, execute } from './main';
 import { Config, Plugin, tsPath, toCached } from './config';
 import * as Interfaces from './interfaces';
 import * as Errors from './errors';
 import * as Flags from './flags';
+import * as Args from './args';
 import { CommandHelp, HelpBase, Help, loadHelpClass } from './help';
 import { toStandardizedId, toConfiguredId } from './help/util';
 import * as Parser from './parser';
 import { Hook } from './interfaces/hooks';
 import { settings, Settings } from './settings';
 import { HelpSection, HelpSectionRenderer, HelpSectionKeyValueTable } from './help/formatter';
-import * as cliUx from './cli-ux';
+import * as ux from './cli-ux';
 declare const flush: (ms?: number) => Promise<void>;
-export { Command, CommandHelp, Config, Errors, Flags, loadHelpClass, Help, HelpBase, HelpSection, HelpSectionRenderer, HelpSectionKeyValueTable, Hook, Interfaces, Parser, Plugin, run, toCached, tsPath, toStandardizedId, toConfiguredId, settings, Settings, flush, cliUx as CliUx, };
+export { Args, Command, CommandHelp, Config, Errors, Flags, loadHelpClass, Help, HelpBase, HelpSection, HelpSectionRenderer, HelpSectionKeyValueTable, Hook, Interfaces, Parser, Plugin, run, toCached, tsPath, toStandardizedId, toConfiguredId, settings, Settings, flush, ux, execute, };

package/lib/index.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CliUx = exports.flush = exports.settings = exports.toConfiguredId = exports.toStandardizedId = exports.tsPath = exports.toCached = exports.run = exports.Plugin = exports.Parser = exports.Interfaces = exports.HelpBase = exports.Help = exports.loadHelpClass = exports.Flags = exports.Errors = exports.Config = exports.CommandHelp = exports.Command = void 0;
-const path = require("path");
+exports.execute = exports.ux = exports.flush = exports.settings = exports.toConfiguredId = exports.toStandardizedId = exports.tsPath = exports.toCached = exports.run = exports.Plugin = exports.Parser = exports.Interfaces = exports.HelpBase = exports.Help = exports.loadHelpClass = exports.Flags = exports.Errors = exports.Config = exports.CommandHelp = exports.Command = exports.Args = void 0;
 const semver = require("semver");
 const command_1 = require("./command");
-exports.Command = command_1.default;
+Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return command_1.Command; } });
 const main_1 = require("./main");
 Object.defineProperty(exports, "run", { enumerable: true, get: function () { return main_1.run; } });
+Object.defineProperty(exports, "execute", { enumerable: true, get: function () { return main_1.execute; } });
 const config_1 = require("./config");
 Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
 Object.defineProperty(exports, "Plugin", { enumerable: true, get: function () { return config_1.Plugin; } });
@@ -18,6 +18,8 @@ const Errors = require("./errors");
 exports.Errors = Errors;
 const Flags = require("./flags");
 exports.Flags = Flags;
+const Args = require("./args");
+exports.Args = Args;
 const help_1 = require("./help");
 Object.defineProperty(exports, "CommandHelp", { enumerable: true, get: function () { return help_1.CommandHelp; } });
 Object.defineProperty(exports, "HelpBase", { enumerable: true, get: function () { return help_1.HelpBase; } });
@@ -30,9 +32,10 @@ const Parser = require("./parser");
 exports.Parser = Parser;
 const settings_1 = require("./settings");
 Object.defineProperty(exports, "settings", { enumerable: true, get: function () { return settings_1.settings; } });
-const cliUx = require("./cli-ux");
-exports.CliUx = cliUx;
-const flush = cliUx.ux.flush;
+const ux = require("./cli-ux");
+exports.ux = ux;
+const util_2 = require("./util");
+const flush = ux.flush;
 exports.flush = flush;
 function checkCWD() {
     try {
@@ -45,8 +48,7 @@ function checkCWD() {
     }
 }
 function checkNodeVersion() {
-    const root = path.join(__dirname, '..');
-    const pjson = require(path.join(root, 'package.json'));
+    const pjson = (0, util_2.requireJson)(__dirname, '..', 'package.json');
     if (!semver.satisfies(process.versions.node, pjson.engines.node)) {
         process.stderr.write(`WARNING\nWARNING Node version must be ${pjson.engines.node} to use this CLI\nWARNING Current node version: ${process.versions.node}\nWARNING\n`);
     }

package/lib/interfaces/args.d.ts

@@ -0,0 +1,22 @@
+import { ArgInput } from './parser';
+/**
+ * Infer the args that are returned by Command.parse. This is useful for when you want to assign the args as a class property.
+ *
+ * @example
+ * export type StatusArgs = Interfaces.InferredArgs<typeof Status.args>
+ *
+ * export default class Status {
+ *   static args = {
+ *     force: Args.boolean({char: 'f', description: 'a flag'}),
+ *   }
+ *
+ *   public args!: StatusArgs
+ *
+ *   public async run(): Promise<StatusArgs> {
+ *     const result = await this.parse(Status)
+ *     this.args = result.args
+ *     return result.args
+ *   }
+ * }
+ */
+export type InferredArgs<T> = T extends ArgInput<infer F> ? F : unknown;

package/lib/interfaces/config.d.ts

@@ -1,8 +1,8 @@
 import { PJSON } from './pjson';
 import { Hooks, Hook } from './hooks';
-import { Command } from './command';
 import { Plugin, Options } from './plugin';
 import { Topic } from './topic';
+import { Command } from '../command';
 export type LoadOptions = Options | string | Config | undefined;
 export type PlatformTypes = 'darwin' | 'linux' | 'win32' | 'aix' | 'freebsd' | 'openbsd' | 'sunos' | 'wsl';
 export type ArchTypes = 'arm' | 'arm64' | 'mips' | 'mipsel' | 'ppc' | 'ppc64' | 's390' | 's390x' | 'x32' | 'x64' | 'x86';
@@ -91,7 +91,6 @@ export interface Config {
     readonly commands: Command.Loadable[];
     readonly topics: Topic[];
     readonly commandIDs: string[];
-    runCommand<T = unknown>(id: string, argv?: string[]): Promise<T>;
     runCommand<T = unknown>(id: string, argv?: string[], cachedCommand?: Command.Loadable): Promise<T>;
     runHook<T extends keyof Hooks>(event: T, opts: Hooks[T]['options'], timeout?: number): Promise<Hook.Result<Hooks[T]['return']>>;
     getAllCommandIDs(): string[];

package/lib/interfaces/flags.d.ts

@@ -3,12 +3,12 @@ import { FlagInput } from './parser';
  * Infer the flags that are returned by Command.parse. This is useful for when you want to assign the flags as a class property.
  *
  * @example
- * export type StatusFlags = Interfaces.InferredFlags<typeof Status.flags & typeof Status.globalFlags>
+ * export type StatusFlags = Interfaces.InferredFlags<typeof Status.flags & typeof Status.baseFlags>
  *
  * export abstract class BaseCommand extends Command {
  *   static enableJsonFlag = true
  *
- *   static globalFlags = {
+ *   static baseFlags = {
  *     config: Flags.string({
  *       description: 'specify config file',
  *     }),

package/lib/interfaces/hooks.d.ts

@@ -1,4 +1,4 @@
-import { Command } from './command';
+import { Command } from '../command';
 import { Config } from './config';
 import { Plugin } from './plugin';
 interface HookMeta {

package/lib/interfaces/index.d.ts

@@ -1,14 +1,14 @@
 export { AlphabetLowercase, AlphabetUppercase } from './alphabet';
 export { Config, ArchTypes, PlatformTypes, LoadOptions } from './config';
-export { Command, Example } from './command';
 export { OclifError, PrettyPrintableError, CommandError } from './errors';
 export { HelpOptions } from './help';
 export { Hook, Hooks } from './hooks';
 export { Manifest } from './manifest';
 export { S3Manifest } from './s3-manifest';
-export { ParserArg, Arg, ParseFn, ParserOutput, ParserInput, ArgToken, OptionalArg, FlagOutput, OutputArgs, OutputFlags, FlagUsageOptions, CLIParseErrorOptions, ArgInput, RequiredArg, Metadata, ParsingToken, FlagToken, List, ListItem, BooleanFlag, Flag, FlagBase, OptionFlag, Input, EnumFlagOptions, DefaultContext, Default, Definition, CompletableOptionFlag, Completion, CompletionContext, FlagInput, CompletableFlag, OptionFlagProps, } from './parser';
+export { BooleanFlag, Flag, OptionFlag, Deprecation } from './parser';
 export { PJSON } from './pjson';
 export { Plugin, PluginOptions, Options } from './plugin';
 export { Topic } from './topic';
 export { TSConfig } from './ts-config';
 export { InferredFlags } from './flags';
+export { InferredArgs } from './args';

package/lib/interfaces/manifest.d.ts

@@ -1,7 +1,7 @@
-import { Command } from './command';
+import { Command } from '../command';
 export interface Manifest {
     version: string;
     commands: {
-        [id: string]: Command;
+        [id: string]: Command.Cached;
     };
 }