@dagger.io/dagger 0.9.3 → 0.9.5

package/dist/introspector/scanner/utils.js

@@ -0,0 +1,124 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../api/client.gen.js";
+/**
+ * Return true if the given class declaration has the decorator @obj on
+ * top of its declaration.
+ * @param object
+ */
+export function isObject(object) {
+    return (ts
+        .getDecorators(object)
+        ?.find((d) => d.expression.getText() === "object") !== undefined);
+}
+/**
+ * Return true if the given method has the decorator @fct on top
+ * of its declaration.
+ *
+ * @param method The method to check
+ */
+export function isFunction(method) {
+    return (ts.getDecorators(method)?.find((d) => d.expression.getText() === "func") !==
+        undefined);
+}
+/**
+ * Return true if the given property is public.
+ *
+ * This function actually in work the reverse, it checks if the property
+ * isn't private nor protected.
+ *
+ * It returns true if the property has no modifiers since no keyword
+ * has been set on the property.
+ *
+ * Example
+ * ```
+ * class Human {
+ *     private age = 22 // Return false
+ *     protected familyName = "Doe" // Return false
+ *
+ *     @field
+ *     name = "John" // Return true
+ *
+ *     city = "Paris" // Return false because there's no decorator
+ * }
+ * ```
+ *
+ * @param property The property to check on.
+ */
+export function isPublicProperty(property) {
+    const decorators = ts.getDecorators(property);
+    if (!decorators) {
+        return false;
+    }
+    if (decorators.find((d) => d.expression.getText() === "field") === undefined) {
+        return false;
+    }
+    const modifiers = ts.getModifiers(property);
+    if (!modifiers) {
+        return true;
+    }
+    return !modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.PrivateKeyword ||
+        modifier.kind === ts.SyntaxKind.ProtectedKeyword);
+}
+/**
+ * Return true if the parameter is optional.
+ *
+ * This includes both optional value defines with `?` and value that
+ * have a default value.
+ *
+ * If there's a default value, its expression is returned in the result.
+ *
+ * @param param The param to check.
+ */
+export function isOptional(param) {
+    const result = { optional: false };
+    const declarations = param.getDeclarations();
+    // Only check if the parameters actually have declarations
+    if (declarations && declarations.length > 0) {
+        const parameterDeclaration = declarations[0];
+        // Convert the symbol declaration into Parameter
+        if (ts.isParameter(parameterDeclaration)) {
+            result.optional =
+                parameterDeclaration.questionToken !== undefined ||
+                    parameterDeclaration.initializer !== undefined;
+            if (parameterDeclaration.initializer !== undefined) {
+                result.defaultValue = formatDefaultValue(parameterDeclaration.initializer.getText());
+            }
+        }
+    }
+    return result;
+}
+function formatDefaultValue(value) {
+    const isSingleQuoteString = () => value.startsWith("'") && value.endsWith("'");
+    if (isSingleQuoteString()) {
+        return `"${value.slice(1, value.length - 1)}"`;
+    }
+    return value;
+}
+/**
+ * Convert a typename into a Dagger Typedef using dynamic typing.
+ */
+export function typeNameToTypedef(typeName) {
+    // If it's a list, remove the '[]' and recall the function to get
+    // the type of list
+    if (typeName.endsWith("[]")) {
+        return {
+            kind: TypeDefKind.Listkind,
+            typeDef: typeNameToTypedef(typeName.slice(0, typeName.length - 2)),
+        };
+    }
+    switch (typeName) {
+        case "string":
+            return { kind: TypeDefKind.Stringkind };
+        case "number":
+            return { kind: TypeDefKind.Integerkind };
+        case "boolean":
+            return { kind: TypeDefKind.Booleankind };
+        case "void":
+            return { kind: TypeDefKind.Voidkind };
+        default:
+            return {
+                kind: TypeDefKind.Objectkind,
+                name: typeName,
+            };
+    }
+}

package/dist/introspector/utils/files.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns a list of path of all files in the given directory
+ */
+export declare function listFiles(dir?: string): Promise<string[]>;
+//# sourceMappingURL=files.d.ts.map

package/dist/introspector/utils/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../../introspector/utils/files.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,wBAAsB,SAAS,CAAC,GAAG,SAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CA0B5D"}

package/dist/introspector/utils/files.js

@@ -0,0 +1,28 @@
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Extensions supported by the loader.
+ */
+const allowedExtensions = [".ts", ".mts"];
+/**
+ * Returns a list of path of all files in the given directory
+ */
+export async function listFiles(dir = ".") {
+    const res = await Promise.all(fs.readdirSync(dir).map(async (file) => {
+        const filepath = path.join(dir, file);
+        // Ignore node_modules and transpiled typescript
+        if (filepath.includes("node_modules") || filepath.includes("dist")) {
+            return [];
+        }
+        const stat = fs.statSync(filepath);
+        if (stat.isDirectory()) {
+            return await listFiles(filepath);
+        }
+        const ext = path.extname(filepath);
+        if (allowedExtensions.find((allowedExt) => allowedExt === ext)) {
+            return [`${dir}/${file}`];
+        }
+        return [];
+    }));
+    return res.reduce((p, c) => [...c, ...p], []);
+}

package/dist/provisioning/bin.d.ts

@@ -1,17 +1,19 @@
-import { Client } from "../api/client.gen.js";
+import { ExecaChildProcess } from "execa";
+import { GraphQLClient } from "graphql-request";
 import { ConnectOpts, EngineConn } from "./engineconn.js";
 /**
  * Bin runs an engine session from a specified binary
  */
 export declare class Bin implements EngineConn {
-    private subProcess?;
+    private _subProcess?;
     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>;
+    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

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

@@ -1 +1 @@
-{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../../provisioning/bin.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAQ7C,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;YAgBnC,WAAW;IAgEzB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAqBrB;;;OAGG;YACW,gBAAgB;YAwEhB,iBAAiB;IA2BzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAU5B;;;;;;;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"}
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../../provisioning/bin.ts"],"names":[],"mappings":"AAGA,OAAO,EAAgB,iBAAiB,EAAE,MAAM,OAAO,CAAA;AAEvD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAgB/C,OAAO,EAAE,WAAW,EAAE,UAAU,EAAiB,MAAM,iBAAiB,CAAA;AAMxE;;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,CAKxB;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;IAgEzB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAqBrB;;;OAGG;YACW,gBAAgB;YAqEhB,iBAAiB;IA2BzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAU5B;;;;;;;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

@@ -1,19 +1,3 @@
-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";
@@ -26,8 +10,8 @@ import * as process from "process";
 import readline from "readline";
 import * as tar from "tar";
 import { fileURLToPath } from "url";
-import { Client } from "../api/client.gen.js";
 import { EngineSessionConnectionTimeoutError, EngineSessionConnectParamsParseError, EngineSessionError, InitEngineSessionBinaryError, } from "../common/errors/index.js";
+import { createGQLClient } from "../graphql/client.js";
 const CLI_HOST = "dl.dagger.io";
 let OVERRIDE_CLI_URL;
 let OVERRIDE_CHECKSUMS_URL;
@@ -35,75 +19,76 @@ let OVERRIDE_CHECKSUMS_URL;
  * 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) {
-        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) {
-                if (opts.LogOutput) {
-                    opts.LogOutput.write("Downloading CLI... ");
-                }
-                this.binPath = yield this.downloadCLI();
-                if (opts.LogOutput) {
-                    opts.LogOutput.write("OK!\n");
-                }
-            }
-            return this.runEngineSession(this.binPath, opts);
-        });
+    get subProcess() {
+        return this._subProcess;
     }
-    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 });
+    async Connect(opts) {
+        if (!this.binPath) {
+            if (opts.LogOutput) {
+                opts.LogOutput.write("Downloading CLI... ");
             }
-            // 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);
-                });
+            this.binPath = await this.downloadCLI();
+            if (opts.LogOutput) {
+                opts.LogOutput.write("OK!\n");
             }
-            catch (e) {
-                // Log the error but do not interrupt program.
-                console.error("could not clean up temporary binary files");
+        }
+        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}`);
             }
-            return binPath;
-        });
+            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;
     }
     /**
      * Traverse up the directory tree to find the package.json file and return the
@@ -135,108 +120,82 @@ export class Bin {
      * runEngineSession execute the engine binary and set up a GraphQL client that
      * target this engine.
      */
-    runEngineSession(binPath, opts) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            const args = [binPath, "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 = execaCommand(args.join(" "), {
-                stdio: "pipe",
-                reject: true,
-                // Kill the process if parent exit.
-                cleanup: true,
-            });
-            // Log the output if the user wants to.
-            if (opts.LogOutput) {
-                (_a = this.subProcess.stderr) === null || _a === void 0 ? void 0 : _a.pipe(opts.LogOutput);
-            }
-            const stdoutReader = readline.createInterface({
-                input: (_b = this.subProcess) === null || _b === void 0 ? void 0 : _b.stdout,
-            });
-            const timeOutDuration = 300000;
-            if (opts.LogOutput) {
-                opts.LogOutput.write("OK!\nEstablishing connection to Engine... ");
+    async runEngineSession(binPath, opts) {
+        const args = [binPath, "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);
             }
-            const connectParams = (yield 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 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;
-        var _e;
-        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; _a = true) {
-                    _d = stdoutReader_1_1.value;
-                    _a = false;
-                    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 });
-                }
-            }
-            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; }
-            }
-            // 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 {
-                yield this.subProcess;
-            }
-            catch (_f) {
-                (_e = this.subProcess) === null || _e === void 0 ? void 0 : _e.catch((e) => {
-                    throw new EngineSessionError(e.stderr);
-                });
-            }
+        if (opts.LogOutput) {
+            opts.LogOutput.write("Creating new Engine session... ");
+        }
+        this._subProcess = execaCommand(args.join(" "), {
+            stdio: "pipe",
+            reject: true,
+            // Kill the process if parent exit.
+            cleanup: true,
         });
+        // 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);
     }
-    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", {
-                    // Set a long timeout to give time for any cache exports to pack layers up
-                    // which currently has to happen synchronously with the session.
-                    forceKillAfterTimeout: 300000, // 5 mins
-                });
+    async readConnectParams(stdoutReader) {
+        for await (const line of stdoutReader) {
+            // 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 });
+        }
+        // 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", {
+                // Set a long timeout to give time for any cache exports to pack layers up
+                // which currently has to happen synchronously with the session.
+                forceKillAfterTimeout: 300000, // 5 mins
+            });
+        }
     }
     /**
      * createCacheDir will create a cache directory on user
@@ -314,70 +273,63 @@ export class Bin {
         }
         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;
-        });
+    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;
     }
-    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;
-        });
+    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;
     }
-    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;
+    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);
         });
+        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