@dagger.io/dagger 0.3.0 → 0.3.2

package/dist/connect.d.ts

@@ -1,15 +1,38 @@
 /// <reference types="node" />
-import Client from "./api/client.gen.js";
 import { Writable } from "node:stream";
+import Client from "./api/client.gen.js";
 /**
  * ConnectOpts defines option used to connect to an engine.
  */
 export interface ConnectOpts {
+    /**
+     * Use to overwrite Dagger workdir
+     * @defaultValue process.cwd()
+     */
     Workdir?: string;
+    /**
+     * Use to overwrite Dagger config
+     * @defaultValue dagger.json
+     */
     ConfigPath?: string;
+    /**
+     * Enable logs output
+     * @example
+     * LogOutput
+     * ```ts
+     * connect(async (client: Client) => {
+      const source = await client.host().workdir().id()
+      ...
+      }, {LogOutput: process.stdout})
+      ```
+     */
     LogOutput?: Writable;
 }
 export type CallbackFct = (client: Client) => Promise<void>;
+export interface ConnectParams {
+    port: number;
+    session_token: string;
+}
 /**
  * connect runs GraphQL server and initializes a
  * GraphQL client to execute query on it through its callback.

package/dist/connect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../connect.ts"],"names":[],"mappings":";AAAA,OAAO,MAAM,MAAM,qBAAqB,CAAA;AAExC,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAEtC;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,CAAC,EAAE,QAAQ,CAAA;CACrB;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;AAE3D;;;;GAIG;AACH,wBAAsB,OAAO,CAC3B,EAAE,EAAE,WAAW,EACf,MAAM,GAAE,WAAgB,GACvB,OAAO,CAAC,IAAI,CAAC,CAgBf"}
+{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../connect.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAEtC,OAAO,MAAM,MAAM,qBAAqB,CAAA;AAGxC;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAA;CACrB;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;AAE3D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,MAAM,CAAA;CACtB;AAED;;;;GAIG;AACH,wBAAsB,OAAO,CAC3B,EAAE,EAAE,WAAW,EACf,MAAM,GAAE,WAAgB,GACvB,OAAO,CAAC,IAAI,CAAC,CAuCf"}

package/dist/connect.js

@@ -7,7 +7,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { getProvisioner, DEFAULT_HOST } from "./provisioning/index.js";
+import Client from "./api/client.gen.js";
+import { Bin, CLI_VERSION } from "./provisioning/index.js";
 /**
  * connect runs GraphQL server and initializes a
  * GraphQL client to execute query on it through its callback.
@@ -18,9 +19,32 @@ export function connect(cb, config = {}) {
         // Create config with default values that may be overridden
         // by config if values are set.
         const _config = Object.assign({ Workdir: process.env["DAGGER_WORKDIR"] || process.cwd(), ConfigPath: process.env["DAGGER_CONFIG"] || "./dagger.json" }, config);
-        // set host to be DAGGER_HOST env otherwise to provisioning defaults
-        const host = process.env["DAGGER_HOST"] || DEFAULT_HOST;
-        const provisioner = getProvisioner(host);
-        yield cb(yield provisioner.Connect(_config)).finally(() => __awaiter(this, void 0, void 0, function* () { return provisioner.Close(); }));
+        let client;
+        let close = null;
+        // Prefer DAGGER_SESSION_PORT if set
+        const daggerSessionPort = process.env["DAGGER_SESSION_PORT"];
+        if (daggerSessionPort) {
+            const sessionToken = process.env["DAGGER_SESSION_TOKEN"];
+            if (!sessionToken) {
+                throw new Error("DAGGER_SESSION_TOKEN must be set when using DAGGER_SESSION_PORT");
+            }
+            client = new Client({
+                host: `127.0.0.1:${daggerSessionPort}`,
+                sessionToken: sessionToken,
+            });
+        }
+        else {
+            // Otherwise, prefer _EXPERIMENTAL_DAGGER_CLI_BIN, with fallback behavior of
+            // downloading the CLI and using that as the bin.
+            const cliBin = process.env["_EXPERIMENTAL_DAGGER_CLI_BIN"];
+            const engineConn = new Bin(cliBin, CLI_VERSION);
+            client = yield engineConn.Connect(_config);
+            close = () => engineConn.Close();
+        }
+        yield cb(client).finally(() => __awaiter(this, void 0, void 0, function* () {
+            if (close) {
+                close();
+            }
+        }));
     });
 }

package/dist/index.d.ts

@@ -2,6 +2,5 @@ import Client from "./api/client.gen.js";
 export { gql } from "graphql-tag";
 export { GraphQLClient } from "graphql-request";
 export { connect, ConnectOpts, CallbackFct } from "./connect.js";
-export { getProvisioner } from "./provisioning/index.js";
 export default Client;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,qBAAqB,CAAA;AAExC,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE/C,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAExD,eAAe,MAAM,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,qBAAqB,CAAA;AAExC,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE/C,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAEhE,eAAe,MAAM,CAAA"}

package/dist/index.js

@@ -2,5 +2,4 @@ import Client from "./api/client.gen.js";
 export { gql } from "graphql-tag";
 export { GraphQLClient } from "graphql-request";
 export { connect } from "./connect.js";
-export { getProvisioner } from "./provisioning/index.js";
 export default Client;

package/dist/provisioning/{docker-provision/image.d.ts → bin.d.ts}

@@ -1,37 +1,45 @@
-import { ConnectOpts, EngineConn } from "../engineconn.js";
-import Client from "../../api/client.gen.js";
+import Client from "../api/client.gen.js";
+import { ConnectOpts, EngineConn } from "./engineconn.js";
 /**
- * DockerImage is an implementation of EngineConn to set up a Dagger
- * Engine session from a pulled docker image.
+ * Bin runs an engine session from a specified binary
  */
-export declare class DockerImage implements EngineConn {
-    private imageRef;
-    private readonly cacheDir;
-    private readonly ENGINE_SESSION_BINARY_PREFIX;
+export declare class Bin implements EngineConn {
     private subProcess?;
-    constructor(u: URL);
-    /**
-     * Generate a unix timestamp in nanosecond
-     */
-    private getRandomId;
+    private binPath?;
+    private cliVersion?;
+    private readonly cacheDir;
+    private readonly DAGGER_CLI_BIN_PREFIX;
+    constructor(binPath?: string, cliVersion?: string);
     Addr(): string;
     Connect(opts: ConnectOpts): Promise<Client>;
+    private downloadCLI;
+    /**
+     * 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 XDG directory, if not, it will use `$HOME/.cache`
-     * as base path.
+     * 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 engine session binary.
+     * 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.
      */
@@ -40,19 +48,17 @@ export declare class DockerImage implements EngineConn {
      * 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;
     /**
-     * pullEngineSessionBin will retrieve Dagger binary from its docker image
-     * and copy it to the local host.
-     * This function automatically resolves host's platform to copy the correct
-     * binary.
-     */
-    private pullEngineSessionBin;
-    /**
-     * runEngineSession execute the engine binary and set up a GraphQL client that
-     * target this engine.
+     * Generate a unix timestamp in nanosecond
      */
-    private runEngineSession;
-    private readPort;
-    Close(): Promise<void>;
+    private getRandomId;
 }
-//# sourceMappingURL=image.d.ts.map
+export declare function _overrideCLIURL(url: string): void;
+export declare function _overrideCLIChecksumsURL(url: string): void;
+//# sourceMappingURL=bin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../../provisioning/bin.ts"],"names":[],"mappings":"AAYA,OAAO,MAAM,MAAM,sBAAsB,CAAA;AAQzC,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAMzD;;GAEG;AACH,qBAAa,GAAI,YAAW,UAAU;IACpC,OAAO,CAAC,UAAU,CAAC,CAAmB;IAEtC,OAAO,CAAC,OAAO,CAAC,CAAQ;IACxB,OAAO,CAAC,UAAU,CAAC,CAAQ;IAE3B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAKxB;IAED,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAW;gBAErC,OAAO,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;IAKjD,IAAI,IAAI,MAAM;IAIR,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;YAOnC,WAAW;IAgEzB;;;OAGG;YACW,gBAAgB;YAgDhB,iBAAiB;IAmBzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B;;;;;;;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;IAatB,OAAO,CAAC,aAAa;IASrB,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/provisioning/bin.js

@@ -0,0 +1,336 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import AdmZip from "adm-zip";
+import * as crypto from "crypto";
+import envPaths from "env-paths";
+import { execaCommand } 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 Client from "../api/client.gen.js";
+import { EngineSessionConnectionTimeoutError, EngineSessionConnectParamsParseError, EngineSessionEOFError, InitEngineSessionBinaryError, } from "../common/errors/index.js";
+const CLI_HOST = "dl.dagger.io";
+let OVERRIDE_CLI_URL;
+let OVERRIDE_CHECKSUMS_URL;
+/**
+ * Bin runs an engine session from a specified binary
+ */
+export class Bin {
+    constructor(binPath, cliVersion) {
+        var _a;
+        this.cacheDir = path.join(`${((_a = process.env.XDG_CACHE_HOME) === null || _a === void 0 ? void 0 : _a.trim()) || envPaths("", { suffix: "" }).cache}`, "dagger");
+        this.DAGGER_CLI_BIN_PREFIX = "dagger";
+        this.binPath = binPath;
+        this.cliVersion = cliVersion;
+    }
+    Addr() {
+        return "http://dagger";
+    }
+    Connect(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.binPath) {
+                this.binPath = yield this.downloadCLI();
+            }
+            return this.runEngineSession(this.binPath, opts);
+        });
+    }
+    downloadCLI() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = yield this.extractArchive(tmpBinDownloadDir, this.normalizedOS());
+                const expectedChecksum = yield 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 (e) {
+                // Log the error but do not interrupt program.
+                console.error("could not clean up temporary binary files");
+            }
+            return binPath;
+        });
+    }
+    /**
+     * runEngineSession execute the engine binary and set up a GraphQL client that
+     * target this engine.
+     */
+    runEngineSession(binPath, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = [binPath, "session"];
+            if (opts.Workdir) {
+                args.push("--workdir", opts.Workdir);
+            }
+            if (opts.Project) {
+                args.push("--project", opts.Project);
+            }
+            this.subProcess = execaCommand(args.join(" "), {
+                stderr: opts.LogOutput || "ignore",
+                reject: true,
+                // Kill the process if parent exit.
+                cleanup: true,
+            });
+            const stdoutReader = readline.createInterface({
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                input: this.subProcess.stdout,
+            });
+            const timeOutDuration = 300000;
+            const connectParams = (yield Promise.race([
+                this.readConnectParams(stdoutReader),
+                new Promise((_, reject) => {
+                    setTimeout(() => {
+                        reject(new EngineSessionConnectionTimeoutError("timeout reading connect params from engine session", { timeOutDuration }));
+                    }, timeOutDuration).unref(); // long timeout to account for extensions, though that should be optimized in future
+                }),
+            ]));
+            return new Client({
+                host: `127.0.0.1:${connectParams.port}`,
+                sessionToken: connectParams.session_token,
+            });
+        });
+    }
+    readConnectParams(stdoutReader) {
+        var _a, stdoutReader_1, stdoutReader_1_1;
+        var _b, e_1, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                for (_a = true, stdoutReader_1 = __asyncValues(stdoutReader); stdoutReader_1_1 = yield stdoutReader_1.next(), _b = stdoutReader_1_1.done, !_b;) {
+                    _d = stdoutReader_1_1.value;
+                    _a = false;
+                    try {
+                        const line = _d;
+                        // parse the 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 });
+                    }
+                    finally {
+                        _a = true;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_a && !_b && (_c = stdoutReader_1.return)) yield _c.call(stdoutReader_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            throw new EngineSessionEOFError("No line was found to parse the engine connect params");
+        });
+    }
+    Close() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((_a = this.subProcess) === null || _a === void 0 ? void 0 : _a.pid) {
+                this.subProcess.kill("SIGTERM", {
+                    forceKillAfterTimeout: 2000,
+                });
+            }
+        });
+    }
+    /**
+     * 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) {
+            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) {
+            return OVERRIDE_CLI_URL;
+        }
+        return `https://${CLI_HOST}/dagger/releases/${this.cliVersion}/${this.cliArchiveName()}`;
+    }
+    cliChecksumURL() {
+        if (OVERRIDE_CHECKSUMS_URL) {
+            return OVERRIDE_CHECKSUMS_URL;
+        }
+        return `https://${CLI_HOST}/dagger/releases/${this.cliVersion}/checksums.txt`;
+    }
+    checksumMap() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // download checksums.txt
+            const checksums = yield fetch(this.cliChecksumURL());
+            if (!checksums.ok) {
+                throw new Error(`failed to download checksums.txt from ${this.cliChecksumURL()}`);
+            }
+            const checksumsText = yield 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;
+        });
+    }
+    expectedChecksum() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const checksumMap = yield 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;
+        });
+    }
+    extractArchive(destDir, os) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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 = yield 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);
+            yield new Promise((resolve, reject) => {
+                var _a, _b;
+                (_a = archiveResp.body) === null || _a === void 0 ? void 0 : _a.pipe(archiveFile);
+                (_b = archiveResp.body) === null || _b === void 0 ? void 0 : _b.on("error", reject);
+                archiveFile.on("finish", resolve);
+            });
+            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/provisioning/default.d.ts

@@ -1,2 +1,2 @@
-export declare const DEFAULT_HOST: string;
+export declare const CLI_VERSION = "0.3.10";
 //# sourceMappingURL=default.d.ts.map

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

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

package/dist/provisioning/default.js

@@ -1,3 +1,2 @@
 // Code generated by dagger. DO NOT EDIT.
-const DEFAULT_IMAGE_REF = "ghcr.io/dagger/engine:v0.3.7@sha256:9ad18aca71b1b1bae137d3ac5b8d1c62bd548d4f3b01c42b48120fdbc1490f22";
-export const DEFAULT_HOST = `docker-image://${DEFAULT_IMAGE_REF}`;
+export const CLI_VERSION = "0.3.10";

package/dist/provisioning/engineconn.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
-import Client from "../api/client.gen.js";
 import { Writable } from "node:stream";
+import Client from "../api/client.gen.js";
 export interface ConnectOpts {
     Workdir?: string;
     Project?: string;

package/dist/provisioning/engineconn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engineconn.d.ts","sourceRoot":"","sources":["../../provisioning/engineconn.ts"],"names":[],"mappings":";AAAA,OAAO,MAAM,MAAM,sBAAsB,CAAA;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAEtC,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,QAAQ,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,IAAI,EAAE,MAAM,MAAM,CAAA;IAElB;;;OAGG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IAE/C;;OAEG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3B"}
+{"version":3,"file":"engineconn.d.ts","sourceRoot":"","sources":["../../provisioning/engineconn.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAEtC,OAAO,MAAM,MAAM,sBAAsB,CAAA;AAEzC,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,QAAQ,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,IAAI,EAAE,MAAM,MAAM,CAAA;IAElB;;;OAGG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IAE/C;;OAEG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3B"}

package/dist/provisioning/index.d.ts

@@ -1,5 +1,4 @@
-export * from "./docker-provision/index.js";
 export * from "./default.js";
 export * from "./engineconn.js";
-export * from "./provisioner.js";
+export * from "./bin.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/provisioning/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../provisioning/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAA;AAC3C,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../provisioning/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,UAAU,CAAA"}

package/dist/provisioning/index.js

@@ -1,4 +1,3 @@
-export * from "./docker-provision/index.js";
 export * from "./default.js";
 export * from "./engineconn.js";
-export * from "./provisioner.js";
+export * from "./bin.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dagger.io/dagger",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "author": "hello@dagger.io",
   "license": "Apache-2.0",
   "types": "./dist/index.d.ts",
@@ -17,31 +17,37 @@
   "main": "dist/index.js",
   "dependencies": {
     "@lifeomic/axios-fetch": "^3.0.1",
-    "axios": "^1.2.0",
+    "adm-zip": "^0.5.10",
+    "env-paths": "^3.0.0",
     "execa": "^6.1.0",
     "graphql": "^16.5.0",
-    "graphql-request": "^5.0.0",
+    "graphql-request": "^5.1.0",
     "graphql-tag": "^2.12.6",
     "node-color-log": "^10.0.2",
-    "node-fetch": "^3.3.0"
+    "node-fetch": "^3.3.0",
+    "tar": "^6.1.13"
   },
   "scripts": {
     "build": "tsc",
+    "watch": "tsc -w",
     "test": "mocha",
     "lint": "yarn eslint --max-warnings=0 .",
     "fmt": "yarn eslint --fix"
   },
   "devDependencies": {
+    "@trivago/prettier-plugin-sort-imports": "^4.0.0",
+    "@types/adm-zip": "^0.5.0",
     "@types/mocha": "latest",
     "@types/node": "~16",
-    "@typescript-eslint/eslint-plugin": "^5.45.1",
-    "@typescript-eslint/parser": "^5.45.1",
-    "eslint": "^8.29.0",
-    "eslint-config-prettier": "^8.5.0",
+    "@types/tar": "^6.1.3",
+    "@typescript-eslint/eslint-plugin": "^5.48.2",
+    "@typescript-eslint/parser": "^5.49.0",
+    "eslint": "^8.32.0",
+    "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-prettier": "^4.2.1",
-    "mocha": "^10.1.0",
-    "prettier": "^2.8.0",
+    "mocha": "^10.2.0",
+    "prettier": "^2.8.3",
     "ts-node": "^10.9.1",
-    "typescript": "^4.9.3"
+    "typescript": "^4.9.4"
   }
 }