zarro 1.173.0 → 1.173.4

package/gulp-tasks/modules/cache.js

@@ -0,0 +1,114 @@
+"use strict";
+(function () {
+    class CacheItem {
+        constructor(value, expires) {
+            this.value = value;
+            this.expires = expires;
+        }
+    }
+    class Cache {
+        constructor() {
+            this._store = {};
+        }
+        /**
+         * reads a value from the cache
+         * if the value is not found, the fallback, if supplied
+         * is returned, otherwise undefined is returned
+         * @param key
+         * @param fallback
+         */
+        read(key, fallback) {
+            const cached = this._findCacheItem(key);
+            return cached === undefined
+                ? fallback
+                : cached.value;
+        }
+        /**
+         * clears all cached values
+         */
+        clear() {
+            this._store = {};
+        }
+        /**
+         * stores a value in the cache
+         * @param key
+         * @param value
+         * @param ttlSeconds
+         */
+        write(key, value, ttlSeconds) {
+            this._store[key] = new CacheItem(value, Date.now() + ttlSeconds);
+        }
+        /**
+         * Runs the generator if there is no cache item with
+         * the provided key and stores the result. Subsequent
+         * calls will skip the generator function to retrieve
+         * from cache until the item expires.
+         * @param key
+         * @param generator
+         * @param ttlSeconds
+         */
+        async through(key, generator, ttlSeconds) {
+            const cached = this._findCacheItem(key);
+            if (cached) {
+                return cached.value;
+            }
+            const result = await generator();
+            this.write(key, result, ttlSeconds);
+            return result;
+        }
+        /**
+         * Runs the generator if there is no cache item with
+         * the provided key and stores the result. Subsequent
+         * calls will skip the generator function to retrieve
+         * from cache until the item expires.
+         * @param key
+         * @param generator
+         * @param ttlSeconds
+         */
+        throughSync(key, generator, ttlSeconds) {
+            const cached = this._findCacheItem(key);
+            if (cached) {
+                return cached.value;
+            }
+            const result = generator();
+            this.write(key, result, ttlSeconds);
+            return result;
+        }
+        _findCacheItem(key) {
+            const result = this._store[key];
+            if (result === undefined) {
+                return undefined;
+            }
+            if (result.expires < Date.now()) {
+                this.forget(key);
+                return undefined;
+            }
+            return result;
+        }
+        /**
+         * creates a new empty cache
+         */
+        create() {
+            return new Cache();
+        }
+        /**
+         * trims expired items from the cache
+         */
+        trim() {
+            for (const key of Object.keys(this._store)) {
+                const item = this._store[key];
+                if (item.expires < Date.now()) {
+                    this.forget(key);
+                }
+            }
+        }
+        /**
+         * forgets the cached item by key
+         * @param key
+         */
+        forget(key) {
+            delete this._store[key];
+        }
+    }
+    module.exports = new Cache();
+})();

package/gulp-tasks/modules/dotnet-cli.js

@@ -5,7 +5,7 @@
     const { isRegExp } = types;
     const ZarroError = requireModule("zarro-error");
     const path = require("path");
-    const { fileExists, readTextFile } = require("yafs");
+    const { fileExists, readTextFile, ls, FsEntities } = require("yafs");
     const { yellow } = requireModule("ansi-colors");
     const q = requireModule("quote-if-required");
     const { pushIfSet, pushFlag } = requireModule("cli-support");
@@ -18,6 +18,7 @@
     const env = requireModule("env");
     const Version = requireModule("version");
     const SystemError = requireModule("system-error");
+    const cache = requireModule("cache");
     const emojiLabels = {
         testing: `🧪 Testing`,
         packing: `📦 Packing`,
@@ -264,7 +265,7 @@
     async function enableNugetSource(source) {
         const toEnable = await tryFindConfiguredNugetSource(source);
         if (!toEnable) {
-            throw new Error(`unable to find source matching: ${JSON.stringify(source)}`);
+            throw new ZarroError(`unable to find source matching: ${JSON.stringify(source)}`);
         }
         await runDotNetWith(["dotnet", "nuget", "enable", "source", toEnable.name], {
             suppressOutput: true
@@ -273,7 +274,7 @@
     async function disableNugetSource(source) {
         const toDisable = await tryFindConfiguredNugetSource(source);
         if (!toDisable) {
-            throw new Error(`unable to find source matching: ${JSON.stringify(source)}`);
+            throw new ZarroError(`unable to find source matching: ${JSON.stringify(source)}`);
         }
         await runDotNetWith(["dotnet", "nuget", "disable", "source", toDisable.name], {
             suppressOutput: true
@@ -334,7 +335,7 @@
         }
         function single(results) {
             if (results.length > 1) {
-                throw new Error(`multiple matches for nuget source by name / url / host: ${JSON.stringify(find)}\nfound:\n${JSON.stringify(allSources, null, 2)}`);
+                throw new ZarroError(`multiple matches for nuget source by name / url / host: ${JSON.stringify(find)}\nfound:\n${JSON.stringify(allSources, null, 2)}`);
             }
             return results[0];
         }
@@ -356,7 +357,7 @@
     async function removeNugetSourceByName(find) {
         const source = await tryFindConfiguredNugetSource(find);
         if (!source) {
-            throw new Error(`Can't find source with '${find}'`);
+            throw new ZarroError(`Can't find source with '${find}'`);
         }
         const result = await runDotNetWith(["nuget", "remove", "source", source.name], { suppressOutput: true });
         if (system.isError(result)) {
@@ -469,7 +470,7 @@ WARNING: 'dotnet pack' ignores --version-suffix when a nuspec file is provided.
             if (await fileExists(test)) {
                 return test;
             }
-            throw new Error(`Unable to resolve '${resolvedPath}' relative to '${containerDir}'`);
+            throw new ZarroError(`Unable to resolve '${resolvedPath}' relative to '${containerDir}'`);
         }
     }
     async function shouldIncludeNuspec(opts) {
@@ -495,7 +496,7 @@ WARNING: 'dotnet pack' ignores --version-suffix when a nuspec file is provided.
     async function nugetPush(opts) {
         validateCommonBuildOptions(opts);
         if (!opts.apiKey) {
-            throw new Error("apiKey was not specified");
+            throw new ZarroError("apiKey was not specified");
         }
         const args = [
             "nuget",
@@ -554,7 +555,7 @@ WARNING: 'dotnet pack' ignores --version-suffix when a nuspec file is provided.
         // for simplicity: return the last system result (at least for now, until there's a reason to get clever)
         if (lastResult === undefined) {
             // this is really here for TS
-            throw new Error(`No build configurations could be determined, which is odd, because there's even a fallback.`);
+            throw new ZarroError(`No build configurations could be determined, which is odd, because there's even a fallback.`);
         }
         return lastResult;
     }
@@ -601,7 +602,7 @@ WARNING: 'dotnet pack' ignores --version-suffix when a nuspec file is provided.
         });
         const result = enabledSources[0];
         if (!result) {
-            throw new Error(`Unable to determine default nuget source. Please specify 'source' on your options.`);
+            throw new ZarroError(`Unable to determine default nuget source. Please specify 'source' on your options.`);
         }
         return result;
     }
@@ -670,6 +671,10 @@ WARNING: 'dotnet pack' ignores --version-suffix when a nuspec file is provided.
         }
     }
     async function runDotNetWith(args, opts) {
+        opts = opts || {};
+        if (opts.suppressOutput === undefined) {
+            opts.suppressOutput = true;
+        }
         let result;
         try {
             result = await system("dotnet", args, {
@@ -677,7 +682,8 @@ WARNING: 'dotnet pack' ignores --version-suffix when a nuspec file is provided.
                 stderr: opts.stderr,
                 suppressOutput: opts.suppressOutput,
                 suppressStdIoInErrors: opts.suppressStdIoInErrors,
-                env: opts.env
+                env: opts.env,
+                cwd: opts.cwd
             });
         }
         catch (e) {
@@ -761,13 +767,34 @@ WARNING: 'dotnet pack' ignores --version-suffix when a nuspec file is provided.
             usingFallback
         });
     }
+    function parsePackageSearchResult(stdout) {
+        const allText = stdout.join(" ");
+        let parsed;
+        try {
+            parsed = JSON.parse(allText);
+        }
+        catch (e) {
+            throw new ZarroError(`Unable to parse json from:\n${allText}`);
+        }
+        if (parsed.problems && parsed.problems.length) {
+            throw new ZarroError(`unable to perform package search (check your access token):\n${parsed.problems.join("\n")}`);
+        }
+        return parsed;
+    }
     async function searchPackages(options) {
         if (!options) {
-            throw new Error(`No options or search string provided`);
+            throw new ZarroError(`No options or search string provided`);
         }
         const opts = typeof options === "string"
             ? { search: options }
             : options;
+        if (opts.skipCache) {
+            return await searchPackages(opts);
+        }
+        return await cache.through(JSON.stringify(opts), async () => await searchPackagesUncached(opts), 60 // cache for a minute
+        );
+    }
+    async function searchPackagesUncached(opts) {
         const args = ["package", "search"];
         pushIfSet(args, opts.source, "--source");
         pushFlag(args, opts.exactMatch, "--exact-match");
@@ -798,7 +825,7 @@ WARNING: 'dotnet pack' ignores --version-suffix when a nuspec file is provided.
             const systemError = rawResult;
             throw wrapSearchError(systemError);
         }
-        const allText = stdout.join(" "), parsed = JSON.parse(allText);
+        const parsed = parsePackageSearchResult(stdout);
         const finalResult = [];
         for (const sourceResult of parsed.searchResult) {
             for (const pkg of sourceResult.packages) {
@@ -828,35 +855,21 @@ WARNING: 'dotnet pack' ignores --version-suffix when a nuspec file is provided.
     function wrapSearchError(e) {
         return new Error(`Unable to perform package search (check your access token if necessary): ${e}`);
     }
-    function parsePackageSearchResult(stdout) {
-        const allText = stdout.join(" ");
-        let parsed;
-        try {
-            parsed = JSON.parse(allText);
-        }
-        catch (e) {
-            throw new Error(`Unable to parse json from:\n${allText}`);
-        }
-        if (parsed.problems && parsed.problems.length) {
-            throw new Error(`unable to perform package search (check your access token):\n${parsed.problems.join("\n")}`);
-        }
-        return parsed;
-    }
     async function installPackage(opts) {
         if (!opts) {
-            throw new Error(`no options passed to 'installPackage' - target project and package name not specified`);
+            throw new ZarroError(`no options passed to 'installPackage' - target project and package name not specified`);
         }
         if (!`${opts.projectFile}`.trim()) {
-            throw new Error(`projectFile not specified`);
+            throw new ZarroError(`projectFile not specified`);
         }
         if (!`${opts.id}`.trim()) {
-            throw new Error(`package id not specified`);
+            throw new ZarroError(`package id not specified`);
         }
         const args = ["add", opts.projectFile, "package", opts.id];
         pushIfSet(args, opts.version, "--version");
         pushIfSet(args, opts.framework, "--framework");
         pushFlag(args, opts.noRestore, "--no-restore");
-        pushIfSet(args, opts.source, "--source");
+        pushIfSet(args, await resolveSourceUrlFor(opts.source), "--source");
         pushIfSet(args, opts.packageDirectory, "--package-directory");
         pushFlag(args, opts.preRelease, "--prerelease");
         if (opts.suppressOutput === undefined) {
@@ -864,6 +877,178 @@ WARNING: 'dotnet pack' ignores --version-suffix when a nuspec file is provided.
         }
         await runDotNetWith(args, opts);
     }
+    const defaultCreateOptions = {
+        skipTemplateUpdateCheck: true
+    };
+    const solutionRegex = /.*\.sln$/i;
+    function isSolution(filePath) {
+        return solutionRegex.test(filePath);
+    }
+    const projectRegex = /.*\.csproj$/i;
+    function isProject(filePath) {
+        return projectRegex.test(filePath);
+    }
+    async function create(opts) {
+        verifyExists(opts, `no options passed to create`);
+        opts = Object.assign(Object.assign({}, defaultCreateOptions), opts);
+        verifyNonEmptyString(opts.template, `template was not specified and is required`);
+        const args = ["new", opts.template];
+        pushIfSet(args, opts.output, "--output");
+        pushIfSet(args, opts.name, "--name");
+        pushFlag(args, opts.skipTemplateUpdateCheck, "--no-update-check");
+        pushIfSet(args, opts.projectFile, "--project");
+        pushIfSet(args, opts.verbosity, "--verbosity");
+        pushFlag(args, opts.enableDiagnostics, "--diagnostics");
+        if (opts.suppressOutput === undefined) {
+            opts.suppressOutput = true;
+        }
+        const newFiles = await runAndReportNewFiles(opts.cwd, () => runDotNetWith(args, opts));
+        return newFiles.find(isSolution)
+            || newFiles.find(isProject)
+            || newFiles[0];
+    }
+    async function runAndReportNewFiles(where, toRun) {
+        const before = new Set(await listDotNetFilesUnder(where));
+        await toRun();
+        const after = await listDotNetFilesUnder(where);
+        const added = [];
+        for (const item of after) {
+            if (!before.has(item)) {
+                added.push(item);
+            }
+        }
+        return added;
+    }
+    async function listDotNetFilesUnder(folder) {
+        return await ls(folder || ".", {
+            entities: FsEntities.files,
+            fullPaths: true,
+            recurse: true,
+            doNotTraverse: [
+                /node_modules/,
+                /[\\/]obj[\\/]/,
+                /[\\/]bin[\\/]/
+            ]
+        });
+    }
+    async function addProjectToSolution(opts) {
+        verifyExists(opts, "no options were passed to 'addProjectToSolution'");
+        verifyNonEmptyString(opts.projectFile, "path to project file is required");
+        verifyNonEmptyString(opts.solutionFile, "path to solution file is required");
+        if (!await fileExists(opts.solutionFile)) {
+            throw new ZarroError(`file not found: ${opts.solutionFile}`);
+        }
+        if (!await fileExists(opts.projectFile)) {
+            throw new ZarroError(`file not found: ${opts.projectFile}`);
+        }
+        const args = ["sln", opts.solutionFile, "add", opts.projectFile];
+        await runDotNetWith(args, opts);
+    }
+    async function listProjects(solutionFile) {
+        const args = ["sln", solutionFile, "list"], basePath = path.dirname(solutionFile), rawResult = await runDotNetWith(args), result = [];
+        for (const line of rawResult.stdout) {
+            const trimmed = line.trim(), test = path.join(basePath, trimmed);
+            if (await fileExists(test)) {
+                result.push(test);
+            }
+        }
+        return result;
+    }
+    async function resolveSourceUrlFor(source) {
+        if (!source) {
+            return undefined;
+        }
+        const lowered = source.toLowerCase();
+        const sources = await listNugetSources();
+        for (const source of sources) {
+            if (source.name.toLowerCase() == lowered) {
+                return source.url;
+            }
+        }
+        // hopefully this is a valid source that dotnet understands
+        // - in my testing, dotnet doesn't understand source names,
+        //   unlike nuget.exe
+        return source;
+    }
+    async function upgradePackages(opts) {
+        verifyExists(opts, "no options provided to upgradePackages");
+        verifyNonEmptyString(opts.pathToProjectOrSolution, "no path to a project or solution was supplied");
+        if (!opts.packages || opts.packages.length === 0) {
+            throw new ZarroError(`no packages were specified`);
+        }
+        if (opts.showProgress === undefined) {
+            opts.showProgress = true;
+        }
+        const { ExecStepContext, Labelers } = require("exec-step"), ctx = new ExecStepContext({
+            labeler: opts.showProgress
+                ? Labelers.interactive
+                : Labelers.none
+        });
+        const projects = isProject(opts.pathToProjectOrSolution)
+            ? [opts.pathToProjectOrSolution]
+            : await listProjects(opts.pathToProjectOrSolution);
+        for (const project of projects) {
+            const projectPackages = await listPackages(project);
+            const toUpgrade = [];
+            for (const pkg of opts.packages) {
+                const test = isRegex(pkg)
+                    ? (s) => pkg.test(s)
+                    : (s) => projectPackages.find(pp => pp.id.toLowerCase() === s.toLowerCase());
+                for (const projectPackage of projectPackages) {
+                    if (test(projectPackage.id)) {
+                        toUpgrade.push(projectPackage.id);
+                    }
+                }
+            }
+            if (toUpgrade.length === 0) {
+            }
+            const message = `searching for ${toUpgrade.length} packages to upgrade in ${project}`;
+            const upstream = await ctx.exec(message, async () => {
+                var _a;
+                return await searchForMultiplePackages(toUpgrade, opts.source, (_a = opts.preRelease) !== null && _a !== void 0 ? _a : false);
+            });
+            for (const pkg of upstream) {
+                await ctx.exec(`installing '${pkg.id}' at version '${pkg.version}' into '${project}'`, async () => await installPackage({
+                    projectFile: project,
+                    id: pkg.id,
+                    version: pkg.version.toString(),
+                    source: opts.source,
+                    noRestore: opts.noRestore,
+                    preRelease: opts.preRelease
+                }));
+            }
+        }
+    }
+    async function searchForMultiplePackages(packageIds, source, preRelease) {
+        // TODO: optimise
+        const promises = packageIds.map(id => searchPackages({
+            search: id,
+            exactMatch: true,
+            preRelease,
+            source,
+            take: 1
+        }));
+        const allResults = await Promise.all(promises), finalResult = [];
+        for (const resultArray of allResults) {
+            for (const result of resultArray) {
+                finalResult.push(result);
+            }
+        }
+        return finalResult;
+    }
+    function isRegex(value) {
+        return value instanceof RegExp;
+    }
+    function verifyExists(value, failMessage) {
+        if (value === undefined || value === null) {
+            throw new ZarroError(failMessage);
+        }
+    }
+    function verifyNonEmptyString(value, failMessage) {
+        if (!`${value}`.trim()) {
+            throw new ZarroError(failMessage);
+        }
+    }
     module.exports = {
         test,
         build,
@@ -881,6 +1066,10 @@ WARNING: 'dotnet pack' ignores --version-suffix when a nuspec file is provided.
         tryFindConfiguredNugetSource,
         incrementTempDbPortHintIfFound,
         searchPackages,
-        installPackage
+        installPackage,
+        upgradePackages,
+        create,
+        listProjects,
+        addProjectToSolution
     };
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zarro",
-  "version": "1.173.0",
+  "version": "1.173.4",
   "description": "Some glue to make gulp easier, perhaps even zero- or close-to-zero-conf",
   "bin": {
     "zarro": "./index.js"
@@ -61,7 +61,7 @@
     "decompress": "^4.2.1",
     "del": "^5.1.0",
     "event-stream": "^4.0.1",
-    "exec-step": "^0.11.0",
+    "exec-step": "^0.14.0",
     "fancy-log": "^1.3.3",
     "gulp": "^4.0.0",
     "gulp-debug": "^4.0.0",

package/types.d.ts

@@ -22,6 +22,7 @@ interface RequireModule<T>
 }
 
 declare global {
+
   function requireModule<T>(module: string): T;
 
 // copied out of @types/fancy-log because imports are being stupid
@@ -82,7 +83,7 @@ declare global {
   }
 
   interface Log {
-    setThreshold(level: number): void;
+    setThreshold(level: number | string): void;
 
     debug(...args: any[]): void;
 
@@ -115,7 +116,9 @@ declare global {
     threshold: LogThreshold;
 
     outputDisabled: boolean;
+
     enableOutput(): void;
+
     disableOutput(): void;
 
   }
@@ -1202,15 +1205,21 @@ declare global {
     stdout: string[];
 
     isResult(): this is SystemResult;
+
     isError(): this is SystemError;
   }
 
   interface SystemResultBuilder {
     withExe(exe: string): SystemResultBuilder;
+
     withArgs(args: string[]): SystemResultBuilder;
+
     withExitCode(code: number): SystemResultBuilder;
+
     withStdErr(lines: string[] | string): SystemResultBuilder;
+
     withStdOut(lines: string[] | string): SystemResultBuilder;
+
     build(): SystemResult;
   }
 
@@ -1244,11 +1253,13 @@ declare global {
   interface System
     extends SystemFunction {
     isError(o: any): o is SystemError;
+
     isResult(o: any): o is SystemResult;
   }
 
   interface TempFile {
     path: string;
+
     destroy(): void;
   }
 
@@ -1262,11 +1273,13 @@ declare global {
   }
 
   type ZarroTestPackage = "local" | "beta" | "latest" | string;
+
   interface TestZarroOptions {
     packageVersion: ZarroTestPackage;
     tasks: string | string[];
     rollback?: boolean;
   }
+
   type TestZarro = (opts: TestZarroOptions) => Promise<void>;
 
   type GulpNugetRestore = (opts: NugetRestoreOptions) => Stream;
@@ -1288,11 +1301,12 @@ declare global {
     gulpNpmRun: (gulp: Gulp) => void;
     isNpmScript: (name: string) => boolean;
   }
+
   type Nuget = (args: string[], opts?: SystemOptions) => Promise<void>;
 
   interface CliSupport {
-    pushIfSet: (args: string[], value: Optional<string | number>, cliSwitch: string) => void;
-    pushFlag: (args: string[], value: Optional<boolean>, cliSwitch: string) => void;
+    pushIfSet: (args: string[], value: Nullable<Optional<string | number>>, cliSwitch: string) => void;
+    pushFlag: (args: string[], value: Nullable<Optional<boolean>>, cliSwitch: string) => void;
   }
 
   interface NugetInstallOptions {
@@ -1324,11 +1338,17 @@ declare global {
 
   interface NugetCli {
     install: (opts: NugetInstallOptions) => Promise<void>;
+
     clearAllCache(): Promise<void>;
+
     clearHttpCache(): Promise<void>;
+
     listSources(): Promise<NugetSource[]>;
+
     addSource(src: NugetAddSourceOptions): Promise<void>;
+
     enableSource(name: string): Promise<void>;
+
     disableSource(name: string): Promise<void>;
   }
 
@@ -1349,6 +1369,7 @@ declare global {
     outputStream?: NodeJS.WriteStream,
     validator?: (s: string) => boolean;
   }
+
   type AskFunction = (message: string, options?: AskOptions) => Promise<string>;
   type Ask = {
     ask: AskFunction
@@ -1373,13 +1394,17 @@ declare global {
 
   interface DotNetBaseOptions
     extends IoConsumers {
-    msbuildProperties?: Dictionary<string>;
-    additionalArguments?: string[];
     verbosity?: DotNetVerbosity | string;
     // when set, errors are returned instead of thrown
     suppressErrors?: boolean;
     suppressStdIoInErrors?: boolean;
     suppressOutput?: boolean;
+  }
+
+  interface DotNetMsBuildOptions
+    extends DotNetBaseOptions {
+    msbuildProperties?: Dictionary<string>;
+    additionalArguments?: string[];
 
     env?: Dictionary<string>;
   }
@@ -1426,7 +1451,7 @@ declare global {
   type GulpDotNetCover = (opts?: GulpDotNetCoverOptions) => Transform;
 
   interface DotNetCommonBuildOptions
-    extends DotNetBaseOptions {
+    extends DotNetMsBuildOptions {
     target: string;
     configuration?: string | string[];
     framework?: string;
@@ -1456,7 +1481,7 @@ declare global {
   }
 
   interface DotNetPackOptions
-    extends DotNetBaseOptions {
+    extends DotNetMsBuildOptions {
     target: string;
     output?: string;
     configuration?: string | string[];
@@ -1485,7 +1510,7 @@ declare global {
   }
 
   interface DotNetCleanOptions
-    extends DotNetBaseOptions {
+    extends DotNetMsBuildOptions {
     target: string;
     framework?: string;
     runtime?: string;
@@ -1494,7 +1519,7 @@ declare global {
   }
 
   interface DotNetNugetPushOptions
-    extends DotNetBaseOptions {
+    extends DotNetMsBuildOptions {
     target: string;
     apiKey?: string;
     symbolApiKey?: string;
@@ -1508,8 +1533,9 @@ declare global {
     timeout?: number;
   }
 
-  interface DotNetSearchPackagesOptions extends DotNetBaseOptions {
-    source?: string;
+  interface DotNetSearchPackagesOptions
+    extends DotNetMsBuildOptions {
+    source?: string | null | undefined;
     search?: string;
     take?: number;
     skip?: number;
@@ -1517,9 +1543,16 @@ declare global {
     preRelease?: boolean;
     configFile?: string;
     latestOnly?: boolean;
+    /**
+     * search results are typically cached in memory
+     * for 1 minute. If you absolutely _must_ have
+     * fresh data, set this to false
+     */
+    skipCache?: boolean;
   }
 
-  interface DotNetInstallNugetPackageOption extends DotNetBaseOptions {
+  interface DotNetInstallNugetPackageOption
+    extends DotNetMsBuildOptions {
     id: string;
     projectFile: string;
     version?: string;
@@ -1533,6 +1566,8 @@ declare global {
   interface IoConsumers {
     stdout?: IoConsumer;
     stderr?: IoConsumer;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv
   }
 
   interface DotNetTestOptions
@@ -1576,6 +1611,42 @@ declare global {
     usingFallback: boolean;
   }
 
+  interface DotNetCreateBaseOptions
+    extends DotNetBaseOptions {
+    output?: string;
+    name: string;
+    dryRun?: boolean;
+    force?: boolean;
+    skipTemplateUpdateCheck?: boolean;
+    enableDiagnostics?: boolean;
+  }
+
+  interface DotNetCreateOptions
+    extends DotNetCreateBaseOptions {
+    template: string;
+    projectFile?: string;
+  }
+
+  interface DotNetAddProjectToSolutionOptions
+    extends DotNetBaseOptions {
+    solutionFile: string;
+    projectFile: string;
+  }
+
+  type StringOrRegex = string | RegExp;
+
+  interface DotNetUpgradePackagesOptions {
+    pathToProjectOrSolution: string;
+    packages: StringOrRegex[],
+    preRelease?: boolean;
+    noRestore?: boolean;
+    source?: string;
+    /**
+     * defaults to true
+     */
+    showProgress?: boolean;
+  }
+
   type DotNetTestFunction = (opts: DotNetTestOptions) => Promise<SystemResult | SystemError>;
   type DotNetBuildFunction = (opts: DotNetBuildOptions) => Promise<SystemResult | SystemError>;
   type DotNetPackFunction = (opts: DotNetPackOptions) => Promise<SystemResult | SystemError>;
@@ -1592,6 +1663,10 @@ declare global {
   type DotNetTryMatchNugetSourceFunction = (nameOrUrlOrHostOrSpec: string | Partial<NugetSource> | RegExp) => Promise<Optional<NugetSource>>;
   type DotNetSearchNugetPackagesFunction = (opts: DotNetSearchPackagesOptions | string) => Promise<PackageInfo[]>;
   type DotNetInstallNugetPackageFunction = (opts: DotNetInstallNugetPackageOption | string) => Promise<void>;
+  type DotNetUpgradePackagesFunction = (opts: DotNetUpgradePackagesOptions) => Promise<void>;
+  type DotNetCreateFunction = (opts: DotNetCreateOptions) => Promise<string>;
+  type DotNetListProjectsFunction = (solutionFile: string) => Promise<string[]>;
+  type DotNetAddProjectToSolutionFunction = (opts: DotNetAddProjectToSolutionOptions) => Promise<void>;
 
   interface DotNetCli {
     clean: DotNetCleanFunction;
@@ -1611,6 +1686,10 @@ declare global {
     incrementTempDbPortHintIfFound: (env: Dictionary<string>) => void;
     searchPackages: DotNetSearchNugetPackagesFunction;
     installPackage: DotNetInstallNugetPackageFunction;
+    upgradePackages: DotNetUpgradePackagesFunction;
+    create: DotNetCreateFunction;
+    listProjects: DotNetListProjectsFunction;
+    addProjectToSolution: DotNetAddProjectToSolutionFunction;
   }
 
   type ReadCsProjNode = (csproj: string) => Promise<string>;
@@ -2066,5 +2145,24 @@ declare global {
     "ZPL-1.1" |
     "ZPL-2.0" |
     "ZPL-2.1"
+
+  interface Cache {
+    read<T>(key: string, fallback?: T): Optional<T>;
+    write<T>(key: string, value: T, ttlSeconds: number): void;
+    through<T>(
+      key: string,
+      generator: Func<Promise<T>>,
+      ttlSeconds: number
+    ): Promise<T>;
+    throughSync<T>(
+      key: string,
+      generator: Func<T>,
+      ttlSeconds: number
+    ): T;
+    create(): Cache;
+    trim(): void;
+    forget(key: string): void;
+    clear(): void;
+  }
 }