@dagger.io/dagger 0.0.1-0

package/dist/src/module/registry.d.ts

@@ -0,0 +1,109 @@
+import "reflect-metadata";
+export type Class = {
+    new (...args: any[]): any;
+};
+export type State = {
+    [property: string]: any;
+};
+export type Args = Record<string, unknown>;
+export type ArgumentOptions = {
+    /**
+     * The contextual value to use for the argument.
+     *
+     * This should only be used for Directory/File or GitRepository/GitRef types.
+     *
+     * An absolute path would be related to the context source directory (the git repo root or the module source root).
+     * A relative path would be relative to the module source root.
+     */
+    defaultPath?: string;
+    /**
+     * Patterns to ignore when loading the contextual argument value.
+     *
+     * This should only be used for Directory types.
+     */
+    ignore?: string[];
+};
+export type FunctionOptions = {
+    /**
+     * The caching behavior of this function.
+     * "never" means no caching.
+     * "session" means caching only for the duration of the current client's session.
+     * A duration string (e.g., "5m", "1h") means persistent caching for that duration.
+     * By default, caching is enabled with a long default set by the engine.
+     */
+    cache?: "never" | "session" | string;
+    /**
+     * An optional alias to use for the function when exposed on the API.
+     */
+    alias?: string;
+};
+/**
+ * Registry stores class and method that have the @object decorator.
+ *
+ * This is a convenient way to make possible the invocation of class' function.
+ *
+ * The decorator @object store the class into the Registry, but also all the
+ * users method's name.
+ * It doesn't consider the `@func` decorator because this is
+ * used by the Dagger API to know what to expose or not.
+ * This might lead to unnecessary data register into the registry, but
+ * we use map as datastructure to optimize the searching process
+ * since we directly look through a key into the `class_` member of
+ * RegistryClass.
+ */
+export declare class Registry {
+    /**
+     * The definition of the @object decorator that should be on top of any
+     * class module that must be exposed to the Dagger API.
+     */
+    object: () => (<T extends Class>(constructor: T) => T);
+    /**
+     * The definition of the @enum decorator that should be on top of any
+     * class module that must be exposed to the Dagger API as enumeration.
+     *
+     * @deprecated In favor of using TypeScript `enum` types.
+     */
+    enumType: () => (<T extends Class>(constructor: T) => T);
+    /**
+     * The definition of @field decorator that should be on top of any
+     * class' property that must be exposed to the Dagger API.
+     *
+     * @deprecated In favor of `@func`
+     * @param alias The alias to use for the field when exposed on the API.
+     */
+    field: (alias?: string) => ((target: object, propertyKey: string) => void);
+    /**
+     * The definition of @func decorator that should be on top of any
+     * class' method that must be exposed to the Dagger API.
+     */
+    func: (opts?: FunctionOptions | string) => ((target: object, propertyKey: string | symbol, descriptor?: PropertyDescriptor) => void);
+    /**
+     * The definition of @check decorator that marks a function as a check.
+     */
+    check: () => ((target: object, propertyKey: string | symbol, descriptor?: PropertyDescriptor) => void);
+    argument: (opts?: ArgumentOptions) => ((target: object, propertyKey: string | undefined, parameterIndex: number) => void);
+    /**
+     * Build a class that is part of the module itself so you can
+     * access its sub functions.
+     *
+     * If there's no class associated, return the object itself.
+     */
+    buildClass(object: string, state: State): any;
+    /**
+     * getResult check for the object and method in the registry and call it
+     * with the given input and state.
+     *
+     * This is the function responsible for any module methods execution.
+     *
+     * @param object The class to look for
+     * @param method The method to call in the class
+     * @param state The current state of the class
+     * @param inputs The input to send to the method to call
+     */
+    getResult(object: string, method: string, state: State, inputs: Args): Promise<any>;
+}
+/**
+ * The default registry used in any module.
+ */
+export declare const registry: Registry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/src/module/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/module/registry.ts"],"names":[],"mappings":"AAIA,OAAO,kBAAkB,CAAA;AAIzB,MAAM,MAAM,KAAK,GAAG;IAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,CAAA;CAAE,CAAA;AAEjD,MAAM,MAAM,KAAK,GAAG;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAAA;AAE/C,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAU1C,MAAM,MAAM,eAAe,GAAG;IAC5B;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAA;IAEpC;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,QAAQ;IACnB;;;OAGG;IACH,MAAM,QAAO,CAAC,CAAC,CAAC,SAAS,KAAK,EAAE,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,CAMpD;IAED;;;;;OAKG;IACH,QAAQ,QAAO,CAAC,CAAC,CAAC,SAAS,KAAK,EAAE,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,CAItD;IAED;;;;;;OAMG;IACH,KAAK,GAAI,QAAQ,MAAM,KAAG,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC,CAIxE;IAED;;;OAGG;IACH,IAAI,GACF,OAAO,eAAe,GAAG,MAAM,KAC9B,CAAC,CACF,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,MAAM,EAC5B,UAAU,CAAC,EAAE,kBAAkB,KAC5B,IAAI,CAAC,CAMT;IAED;;OAEG;IACH,KAAK,QAAO,CAAC,CACX,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,MAAM,EAC5B,UAAU,CAAC,EAAE,kBAAkB,KAC5B,IAAI,CAAC,CAMT;IAED,QAAQ,GACN,OAAO,eAAe,KACrB,CAAC,CACF,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,cAAc,EAAE,MAAM,KACnB,IAAI,CAAC,CAMT;IAED;;;;;OAKG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,GAAG;IAY7C;;;;;;;;;;OAUG;IACG,SAAS,CACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,IAAI,GACX,OAAO,CAAC,GAAG,CAAC;CAiChB;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,UAAiB,CAAA"}

package/dist/src/module/registry.js

@@ -0,0 +1,123 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// @experimentalDecorators
+// @emitDecoratorMetadata
+import "reflect-metadata";
+import { UnknownDaggerError } from "../common/errors/index.js";
+/**
+ * Registry stores class and method that have the @object decorator.
+ *
+ * This is a convenient way to make possible the invocation of class' function.
+ *
+ * The decorator @object store the class into the Registry, but also all the
+ * users method's name.
+ * It doesn't consider the `@func` decorator because this is
+ * used by the Dagger API to know what to expose or not.
+ * This might lead to unnecessary data register into the registry, but
+ * we use map as datastructure to optimize the searching process
+ * since we directly look through a key into the `class_` member of
+ * RegistryClass.
+ */
+export class Registry {
+    /**
+     * The definition of the @object decorator that should be on top of any
+     * class module that must be exposed to the Dagger API.
+     */
+    object = () => {
+        return (constructor) => {
+            Reflect.defineMetadata(constructor.name, { class_: constructor }, this);
+            return constructor;
+        };
+    };
+    /**
+     * The definition of the @enum decorator that should be on top of any
+     * class module that must be exposed to the Dagger API as enumeration.
+     *
+     * @deprecated In favor of using TypeScript `enum` types.
+     */
+    enumType = () => {
+        return (constructor) => {
+            return constructor;
+        };
+    };
+    /**
+     * The definition of @field decorator that should be on top of any
+     * class' property that must be exposed to the Dagger API.
+     *
+     * @deprecated In favor of `@func`
+     * @param alias The alias to use for the field when exposed on the API.
+     */
+    field = (alias) => {
+        return (target, propertyKey) => {
+            // A placeholder to declare field in the registry.
+        };
+    };
+    /**
+     * The definition of @func decorator that should be on top of any
+     * class' method that must be exposed to the Dagger API.
+     */
+    func = (opts) => {
+        return (target, propertyKey, descriptor) => { };
+    };
+    /**
+     * The definition of @check decorator that marks a function as a check.
+     */
+    check = () => {
+        return (target, propertyKey, descriptor) => { };
+    };
+    argument = (opts) => {
+        return (target, propertyKey, parameterIndex) => { };
+    };
+    /**
+     * Build a class that is part of the module itself so you can
+     * access its sub functions.
+     *
+     * If there's no class associated, return the object itself.
+     */
+    buildClass(object, state) {
+        const resolver = Reflect.getMetadata(object, this);
+        if (!resolver) {
+            return object;
+        }
+        let r = Object.create(resolver.class_.prototype);
+        r = Object.assign(r, state);
+        return r;
+    }
+    /**
+     * getResult check for the object and method in the registry and call it
+     * with the given input and state.
+     *
+     * This is the function responsible for any module methods execution.
+     *
+     * @param object The class to look for
+     * @param method The method to call in the class
+     * @param state The current state of the class
+     * @param inputs The input to send to the method to call
+     */
+    async getResult(object, method, state, inputs) {
+        // Retrieve the resolver class from its key
+        const resolver = Reflect.getMetadata(object, this);
+        if (!resolver) {
+            throw new UnknownDaggerError(`${object} is not register as a resolver`, {});
+        }
+        // If method is nil, apply the constructor.
+        if (method === "") {
+            return new resolver.class_(...Object.values(inputs));
+        }
+        // Instantiate the class without calling the constructor
+        let r = Object.create(resolver.class_.prototype);
+        // Safety check to make sure the method called exist in the class
+        // to avoid the app to crash brutally.
+        if (!r[method]) {
+            throw new UnknownDaggerError(`${method} is not registered in the resolver ${object}`, {});
+        }
+        // Apply state to the class
+        r = Object.assign(r, state);
+        // Execute and return the result
+        return await r[method](...Object.values(inputs));
+    }
+}
+/**
+ * The default registry used in any module.
+ */
+export const registry = new Registry();

package/dist/src/provisioning/bin.d.ts

@@ -0,0 +1,77 @@
+import { ResultPromise } from "execa";
+import { GraphQLClient } from "graphql-request";
+import { ConnectOpts, EngineConn } from "./engineconn.js";
+export type ExecaChildProcess = ResultPromise<{
+    stdio: "pipe";
+    reject: true;
+    cleanup: true;
+}>;
+/**
+ * Bin runs an engine session from a specified binary
+ */
+export declare class Bin implements EngineConn {
+    private _subProcess?;
+    private binPath?;
+    private cliVersion?;
+    private readonly cacheDir;
+    private readonly DAGGER_CLI_BIN_PREFIX;
+    constructor(binPath?: string, cliVersion?: string);
+    Addr(): string;
+    get subProcess(): ExecaChildProcess | undefined;
+    Connect(opts: ConnectOpts): Promise<GraphQLClient>;
+    private downloadCLI;
+    /**
+     * Traverse up the directory tree to find the package.json file and return the
+     * SDK version.
+     * @returns the SDK version or "n/a" if the version cannot be found.
+     */
+    private getSDKVersion;
+    /**
+     * runEngineSession execute the engine binary and set up a GraphQL client that
+     * target this engine.
+     */
+    private runEngineSession;
+    private readConnectParams;
+    Close(): Promise<void>;
+    /**
+     * createCacheDir will create a cache directory on user
+     * host to store dagger binary.
+     *
+     * If set, it will use envPaths to determine system's cache directory,
+     * if not, it will use `$HOME/.cache` as base path.
+     * Nothing happens if the directory already exists.
+     */
+    private createCacheDir;
+    /**
+     * buildBinPath create a path to output dagger cli binary.
+     *
+     * It will store it in the cache directory with a name composed
+     * of the base engine session as constant and the engine identifier.
+     */
+    private buildBinPath;
+    /**
+     * buildExePath create a path to output dagger cli binary.
+     */
+    private buildOsExePath;
+    /**
+     * normalizedArch returns the architecture name used by the rest of our SDKs.
+     */
+    private normalizedArch;
+    /**
+     * normalizedOS returns the os name used by the rest of our SDKs.
+     */
+    private normalizedOS;
+    private cliArchiveName;
+    private cliArchiveURL;
+    private cliChecksumURL;
+    private checksumMap;
+    private expectedChecksum;
+    private extractArchive;
+    /**
+     * Generate a unix timestamp in nanosecond
+     */
+    private getRandomId;
+}
+export declare function _overrideCLIURL(url: string): void;
+export declare function _overrideCLIChecksumsURL(url: string): void;
+//# sourceMappingURL=bin.d.ts.map

package/dist/src/provisioning/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../../../src/provisioning/bin.ts"],"names":[],"mappings":"AAGA,OAAO,EAAS,aAAa,EAAE,MAAM,OAAO,CAAA;AAE5C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAgB/C,OAAO,EAAE,WAAW,EAAE,UAAU,EAAiB,MAAM,iBAAiB,CAAA;AAMxE,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC;IAC5C,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,IAAI,CAAA;IACZ,OAAO,EAAE,IAAI,CAAA;CACd,CAAC,CAAA;AAEF;;GAEG;AACH,qBAAa,GAAI,YAAW,UAAU;IACpC,OAAO,CAAC,WAAW,CAAC,CAAmB;IAEvC,OAAO,CAAC,OAAO,CAAC,CAAQ;IACxB,OAAO,CAAC,UAAU,CAAC,CAAQ;IAE3B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAGxB;IAED,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAW;gBAErC,OAAO,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;IAKjD,IAAI,IAAI,MAAM;IAId,IAAI,UAAU,IAAI,iBAAiB,GAAG,SAAS,CAE9C;IAEK,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC;YAgB1C,WAAW;IAkEzB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAqBrB;;;OAGG;YACW,gBAAgB;YA2EhB,iBAAiB;IA6BzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5B;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAItB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAOpB;;OAEG;IACH,OAAO,CAAC,cAAc;IAWtB;;OAEG;IACH,OAAO,CAAC,cAAc;IAStB;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,cAAc;YAOR,WAAW;YAkBX,gBAAgB;YAWhB,cAAc;IA4C5B;;OAEG;IACH,OAAO,CAAC,WAAW;CAGpB;AAGD,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAEjD;AAGD,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAE1D"}

package/dist/src/provisioning/bin.js

@@ -0,0 +1,353 @@
+import AdmZip from "adm-zip";
+import * as crypto from "crypto";
+import envPaths from "env-paths";
+import { execa } from "execa";
+import * as fs from "fs";
+import fetch from "node-fetch";
+import * as os from "os";
+import * as path from "path";
+import * as process from "process";
+import readline from "readline";
+import * as tar from "tar";
+import { fileURLToPath } from "url";
+import { EngineSessionConnectionTimeoutError, EngineSessionConnectParamsParseError, EngineSessionError, InitEngineSessionBinaryError, } from "../common/errors/index.js";
+import { createGQLClient } from "../common/graphql/client.js";
+let OVERRIDE_CLI_URL = "";
+let OVERRIDE_CHECKSUMS_URL = "";
+const CLI_HOST = "dl.dagger.io";
+/**
+ * Bin runs an engine session from a specified binary
+ */
+export class Bin {
+    _subProcess;
+    binPath;
+    cliVersion;
+    cacheDir = path.join(`${process.env.XDG_CACHE_HOME?.trim() || envPaths("", { suffix: "" }).cache}`, "dagger");
+    DAGGER_CLI_BIN_PREFIX = "dagger";
+    constructor(binPath, cliVersion) {
+        this.binPath = binPath;
+        this.cliVersion = cliVersion;
+    }
+    Addr() {
+        return "http://dagger";
+    }
+    get subProcess() {
+        return this._subProcess;
+    }
+    async Connect(opts) {
+        if (!this.binPath) {
+            if (opts.LogOutput) {
+                opts.LogOutput.write("Downloading CLI... ");
+            }
+            this.binPath = await this.downloadCLI();
+            if (opts.LogOutput) {
+                opts.LogOutput.write("OK!\n");
+            }
+        }
+        return this.runEngineSession(this.binPath, opts);
+    }
+    async downloadCLI() {
+        if (!this.cliVersion) {
+            throw new Error("cliVersion is not set");
+        }
+        const binPath = this.buildBinPath();
+        // Create a temporary bin file path
+        this.createCacheDir();
+        const tmpBinDownloadDir = fs.mkdtempSync(path.join(this.cacheDir, `temp-${this.getRandomId()}`));
+        const tmpBinPath = this.buildOsExePath(tmpBinDownloadDir, this.DAGGER_CLI_BIN_PREFIX);
+        try {
+            // download an archive and use appropriate extraction depending on platforms (zip on windows, tar.gz on other platforms)
+            const actualChecksum = await this.extractArchive(tmpBinDownloadDir, this.normalizedOS());
+            const expectedChecksum = await this.expectedChecksum();
+            if (actualChecksum !== expectedChecksum) {
+                throw new Error(`checksum mismatch: expected ${expectedChecksum}, got ${actualChecksum}`);
+            }
+            fs.chmodSync(tmpBinPath, 0o700);
+            fs.renameSync(tmpBinPath, binPath);
+            fs.rmSync(tmpBinDownloadDir, { recursive: true });
+        }
+        catch (e) {
+            fs.rmSync(tmpBinDownloadDir, { recursive: true });
+            throw new InitEngineSessionBinaryError(`failed to download dagger cli binary: ${e}`, {
+                cause: e,
+            });
+        }
+        // Remove all temporary binary files
+        // Ignore current dagger cli or other files that have not be
+        // created by this SDK.
+        try {
+            const files = fs.readdirSync(this.cacheDir);
+            files.forEach((file) => {
+                const filePath = path.join(this.cacheDir, file);
+                if (filePath === binPath ||
+                    !file.startsWith(this.DAGGER_CLI_BIN_PREFIX)) {
+                    return;
+                }
+                fs.unlinkSync(filePath);
+            });
+        }
+        catch {
+            // Log the error but do not interrupt program.
+            console.error("could not clean up temporary binary files");
+        }
+        return binPath;
+    }
+    /**
+     * Traverse up the directory tree to find the package.json file and return the
+     * SDK version.
+     * @returns the SDK version or "n/a" if the version cannot be found.
+     */
+    getSDKVersion() {
+        const currentFileUrl = import.meta.url;
+        const currentFilePath = fileURLToPath(currentFileUrl);
+        let currentPath = path.dirname(currentFilePath);
+        while (currentPath !== path.parse(currentPath).root) {
+            const packageJsonPath = path.join(currentPath, "package.json");
+            if (fs.existsSync(packageJsonPath)) {
+                try {
+                    const packageJsonContent = fs.readFileSync(packageJsonPath, "utf8");
+                    const packageJson = JSON.parse(packageJsonContent);
+                    return packageJson.version;
+                }
+                catch {
+                    return "n/a";
+                }
+            }
+            else {
+                currentPath = path.join(currentPath, "..");
+            }
+        }
+    }
+    /**
+     * runEngineSession execute the engine binary and set up a GraphQL client that
+     * target this engine.
+     */
+    async runEngineSession(binPath, opts) {
+        const args = ["session"];
+        const sdkVersion = this.getSDKVersion();
+        const flagsAndValues = [
+            { flag: "--workdir", value: opts.Workdir },
+            { flag: "--project", value: opts.Project },
+            { flag: "--label", value: "dagger.io/sdk.name:nodejs" },
+            { flag: "--label", value: `dagger.io/sdk.version:${sdkVersion}` },
+        ];
+        flagsAndValues.forEach((pair) => {
+            if (pair.value) {
+                args.push(pair.flag, pair.value);
+            }
+        });
+        if (opts.LogOutput) {
+            opts.LogOutput.write("Creating new Engine session... ");
+        }
+        this._subProcess = execa(binPath, args, {
+            stdio: "pipe",
+            reject: true,
+            // Kill the process if parent exit.
+            cleanup: true,
+            // Set a long timeout to give time for any cache exports to pack layers up
+            // which currently has to happen synchronously with the session.
+            forceKillAfterDelay: 300000,
+        });
+        // Log the output if the user wants to.
+        if (opts.LogOutput) {
+            this._subProcess.stderr?.pipe(opts.LogOutput);
+        }
+        const stdoutReader = readline.createInterface({
+            input: this._subProcess?.stdout,
+        });
+        const timeOutDuration = 300000;
+        if (opts.LogOutput) {
+            opts.LogOutput.write("OK!\nEstablishing connection to Engine... ");
+        }
+        const connectParams = (await Promise.race([
+            this.readConnectParams(stdoutReader),
+            new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new EngineSessionConnectionTimeoutError("Engine connection timeout", {
+                        timeOutDuration,
+                    }));
+                }, timeOutDuration).unref(); // long timeout to account for extensions, though that should be optimized in future
+            }),
+        ]));
+        if (opts.LogOutput) {
+            opts.LogOutput.write("OK!\n");
+        }
+        return createGQLClient(connectParams.port, connectParams.session_token);
+    }
+    async readConnectParams(stdoutReader) {
+        for await (const line of stdoutReader) {
+            // parse the line as json-encoded connect params
+            const connectParams = JSON.parse(line);
+            if (connectParams.port && connectParams.session_token) {
+                return connectParams;
+            }
+            throw new EngineSessionConnectParamsParseError(`invalid connect params: ${line}`, {
+                parsedLine: line,
+            });
+        }
+        // Need to find a better way to handle this part
+        // At this stage something wrong happened, `for await` didn't return anything
+        // await the subprocess to catch the error
+        try {
+            await this.subProcess;
+        }
+        catch {
+            this.subProcess?.catch((e) => {
+                throw new EngineSessionError(e.stderr);
+            });
+        }
+    }
+    async Close() {
+        if (this.subProcess?.pid) {
+            this.subProcess.kill("SIGTERM");
+        }
+    }
+    /**
+     * createCacheDir will create a cache directory on user
+     * host to store dagger binary.
+     *
+     * If set, it will use envPaths to determine system's cache directory,
+     * if not, it will use `$HOME/.cache` as base path.
+     * Nothing happens if the directory already exists.
+     */
+    createCacheDir() {
+        fs.mkdirSync(this.cacheDir, { mode: 0o700, recursive: true });
+    }
+    /**
+     * buildBinPath create a path to output dagger cli binary.
+     *
+     * It will store it in the cache directory with a name composed
+     * of the base engine session as constant and the engine identifier.
+     */
+    buildBinPath() {
+        return this.buildOsExePath(this.cacheDir, `${this.DAGGER_CLI_BIN_PREFIX}-${this.cliVersion}`);
+    }
+    /**
+     * buildExePath create a path to output dagger cli binary.
+     */
+    buildOsExePath(destinationDir, filename) {
+        const binPath = path.join(destinationDir, filename);
+        switch (this.normalizedOS()) {
+            case "windows":
+                return `${binPath}.exe`;
+            default:
+                return binPath;
+        }
+    }
+    /**
+     * normalizedArch returns the architecture name used by the rest of our SDKs.
+     */
+    normalizedArch() {
+        switch (os.arch()) {
+            case "x64":
+                return "amd64";
+            default:
+                return os.arch();
+        }
+    }
+    /**
+     * normalizedOS returns the os name used by the rest of our SDKs.
+     */
+    normalizedOS() {
+        switch (os.platform()) {
+            case "win32":
+                return "windows";
+            default:
+                return os.platform();
+        }
+    }
+    cliArchiveName() {
+        if (OVERRIDE_CLI_URL && OVERRIDE_CLI_URL != "") {
+            return path.basename(new URL(OVERRIDE_CLI_URL).pathname);
+        }
+        let ext = "tar.gz";
+        if (this.normalizedOS() === "windows") {
+            ext = "zip";
+        }
+        return `dagger_v${this.cliVersion}_${this.normalizedOS()}_${this.normalizedArch()}.${ext}`;
+    }
+    cliArchiveURL() {
+        if (OVERRIDE_CLI_URL && OVERRIDE_CLI_URL != "") {
+            return OVERRIDE_CLI_URL;
+        }
+        return `https://${CLI_HOST}/dagger/releases/${this.cliVersion}/${this.cliArchiveName()}`;
+    }
+    cliChecksumURL() {
+        if (OVERRIDE_CHECKSUMS_URL && OVERRIDE_CHECKSUMS_URL != "") {
+            return OVERRIDE_CHECKSUMS_URL;
+        }
+        return `https://${CLI_HOST}/dagger/releases/${this.cliVersion}/checksums.txt`;
+    }
+    async checksumMap() {
+        // download checksums.txt
+        const checksums = await fetch(this.cliChecksumURL());
+        if (!checksums.ok) {
+            throw new Error(`failed to download checksums.txt from ${this.cliChecksumURL()}`);
+        }
+        const checksumsText = await checksums.text();
+        // iterate over lines filling in map of filename -> checksum
+        const checksumMap = new Map();
+        for (const line of checksumsText.split("\n")) {
+            const [checksum, filename] = line.split(/\s+/);
+            checksumMap.set(filename, checksum);
+        }
+        return checksumMap;
+    }
+    async expectedChecksum() {
+        const checksumMap = await this.checksumMap();
+        const expectedChecksum = checksumMap.get(this.cliArchiveName());
+        if (!expectedChecksum) {
+            throw new Error(`failed to find checksum for ${this.cliArchiveName()} in checksums.txt`);
+        }
+        return expectedChecksum;
+    }
+    async extractArchive(destDir, os) {
+        // extract the dagger binary in the cli archive and return the archive of the .zip for windows and .tar.gz for other plateforms
+        const archiveResp = await fetch(this.cliArchiveURL());
+        if (!archiveResp.ok) {
+            throw new Error(`failed to download dagger cli archive from ${this.cliArchiveURL()}`);
+        }
+        if (!archiveResp.body) {
+            throw new Error("archive response body is null");
+        }
+        // create a temporary file to store the archive
+        const archivePath = path.join(destDir, os === "windows" ? "dagger.zip" : "dagger.tar.gz");
+        const archiveFile = fs.createWriteStream(archivePath);
+        await new Promise((resolve, reject) => {
+            archiveResp.body?.pipe(archiveFile);
+            archiveResp.body?.on("error", reject);
+            archiveFile.on("finish", () => resolve(undefined));
+        });
+        const actualChecksum = crypto
+            .createHash("sha256")
+            .update(fs.readFileSync(archivePath))
+            .digest("hex");
+        if (os === "windows") {
+            const zip = new AdmZip(archivePath);
+            // extract just dagger.exe to the destdir
+            zip.extractEntryTo("dagger.exe", destDir, false, true);
+        }
+        else {
+            tar.extract({
+                cwd: destDir,
+                file: archivePath,
+                sync: true,
+            });
+        }
+        return actualChecksum;
+    }
+    /**
+     * Generate a unix timestamp in nanosecond
+     */
+    getRandomId() {
+        return process.hrtime.bigint().toString();
+    }
+}
+// Only meant for tests
+export function _overrideCLIURL(url) {
+    OVERRIDE_CLI_URL = url;
+}
+// Only meant for tests
+export function _overrideCLIChecksumsURL(url) {
+    OVERRIDE_CHECKSUMS_URL = url;
+}

package/dist/src/provisioning/default.d.ts

@@ -0,0 +1,2 @@
+export declare const CLI_VERSION = "0.19.9";
+//# sourceMappingURL=default.d.ts.map

package/dist/src/provisioning/default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../src/provisioning/default.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,WAAW,WAAW,CAAA"}

package/dist/src/provisioning/default.js

@@ -0,0 +1,2 @@
+// Code generated by dagger. DO NOT EDIT.
+export const CLI_VERSION = "0.19.9";