@dagger.io/dagger 0.9.2 → 0.9.4

package/dist/api/utils.js

@@ -1,12 +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());
-    });
-};
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { ClientError, gql } from "graphql-request";
 import { GraphQLRequestError, TooManyNestedObjectsError, UnknownDaggerError, NotAwaitedRequestError, ExecError, } from "../common/errors/index.js";
@@ -17,9 +8,8 @@ function buildArgs(args) {
     const metadata = args.__metadata || {};
     // Remove unwanted quotes
     const formatValue = (key, value) => {
-        var _a;
         // Special treatment for enumeration, they must be inserted without quotes
-        if ((_a = metadata[key]) === null || _a === void 0 ? void 0 : _a.is_enum) {
+        if (metadata[key]?.is_enum) {
             return JSON.stringify(value).replace(/['"]+/g, "");
         }
         return JSON.stringify(value).replace(/\{"[a-zA-Z]+":|,"[a-zA-Z]+":/gi, (str) => {
@@ -48,51 +38,49 @@ function buildArgs(args) {
  * Find QueryTree, convert them into GraphQl query
  * then compute and return the result to the appropriate field
  */
-function computeNestedQuery(query, client) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Check if there is a nested queryTree to be executed
-        const isQueryTree = (value) => value["_queryTree"] !== undefined;
-        // Check if there is a nested array of queryTree to be executed
-        const isArrayQueryTree = (value) => value.every((v) => v instanceof Object && isQueryTree(v));
-        // Prepare query tree for final query by computing nested queries
-        // and building it with their results.
-        const computeQueryTree = (value) => __awaiter(this, void 0, void 0, function* () {
-            // Resolve sub queries if operation's args is a subquery
-            for (const op of value["_queryTree"]) {
-                yield computeNestedQuery([op], client);
+async function computeNestedQuery(query, client) {
+    // Check if there is a nested queryTree to be executed
+    const isQueryTree = (value) => value["_queryTree"] !== undefined;
+    // Check if there is a nested array of queryTree to be executed
+    const isArrayQueryTree = (value) => value.every((v) => v instanceof Object && isQueryTree(v));
+    // Prepare query tree for final query by computing nested queries
+    // and building it with their results.
+    const computeQueryTree = async (value) => {
+        // Resolve sub queries if operation's args is a subquery
+        for (const op of value["_queryTree"]) {
+            await computeNestedQuery([op], client);
+        }
+        // push an id that will be used by the container
+        return buildQuery([
+            ...value["_queryTree"],
+            {
+                operation: "id",
+            },
+        ]);
+    };
+    // Remove all undefined args and assert args type
+    const queryToExec = query.filter((q) => !!q.args);
+    for (const q of queryToExec) {
+        await Promise.all(
+        // Compute nested query for single object
+        Object.entries(q.args).map(async ([key, value]) => {
+            if (value instanceof Object && isQueryTree(value)) {
+                // push an id that will be used by the container
+                const getQueryTree = await computeQueryTree(value);
+                q.args[key] = await compute(getQueryTree, client);
             }
-            // push an id that will be used by the container
-            return buildQuery([
-                ...value["_queryTree"],
-                {
-                    operation: "id",
-                },
-            ]);
-        });
-        // Remove all undefined args and assert args type
-        const queryToExec = query.filter((q) => !!q.args);
-        for (const q of queryToExec) {
-            yield Promise.all(
-            // Compute nested query for single object
-            Object.entries(q.args).map(([key, value]) => __awaiter(this, void 0, void 0, function* () {
-                if (value instanceof Object && isQueryTree(value)) {
+            // Compute nested query for array of object
+            if (Array.isArray(value) && isArrayQueryTree(value)) {
+                const tmp = q.args[key];
+                for (let i = 0; i < value.length; i++) {
                     // push an id that will be used by the container
-                    const getQueryTree = yield computeQueryTree(value);
-                    q.args[key] = yield compute(getQueryTree, client);
-                }
-                // Compute nested query for array of object
-                if (Array.isArray(value) && isArrayQueryTree(value)) {
-                    const tmp = q.args[key];
-                    for (let i = 0; i < value.length; i++) {
-                        // push an id that will be used by the container
-                        const getQueryTree = yield computeQueryTree(value[i]);
-                        tmp[i] = yield compute(getQueryTree, client);
-                    }
-                    q.args[key] = tmp;
+                    const getQueryTree = await computeQueryTree(value[i]);
+                    tmp[i] = await compute(getQueryTree, client);
                 }
-            })));
-        }
-    });
+                q.args[key] = tmp;
+            }
+        }));
+    }
 }
 /**
  * Convert the queryTree into a GraphQL query
@@ -113,12 +101,10 @@ export function buildQuery(q) {
  * @param client | GraphQLClient
  * @returns
  */
-export function computeQuery(q, client) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield computeNestedQuery(q, client);
-        const query = buildQuery(q);
-        return yield compute(query, client);
-    });
+export async function computeQuery(q, client) {
+    await computeNestedQuery(q, client);
+    const query = buildQuery(q);
+    return await compute(query, client);
 }
 /**
  * Return a Graphql query result flattened
@@ -145,40 +131,37 @@ export function queryFlatten(response) {
  * return a flatten result
  * @hidden
  */
-export function compute(query, client) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-    return __awaiter(this, void 0, void 0, function* () {
-        let computeQuery;
-        try {
-            computeQuery = yield client.request(gql `
+export async function compute(query, client) {
+    let computeQuery;
+    try {
+        computeQuery = await client.request(gql `
         ${query}
       `);
-        }
-        catch (e) {
-            if (e instanceof ClientError) {
-                const msg = (_c = (_b = (_a = e.response.errors) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.message) !== null && _c !== void 0 ? _c : `API Error`;
-                const ext = (_e = (_d = e.response.errors) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.extensions;
-                if ((ext === null || ext === void 0 ? void 0 : ext._type) === "EXEC_ERROR") {
-                    throw new ExecError(msg, {
-                        cmd: (_f = ext.cmd) !== null && _f !== void 0 ? _f : [],
-                        exitCode: (_g = ext.exitCode) !== null && _g !== void 0 ? _g : -1,
-                        stdout: (_h = ext.stdout) !== null && _h !== void 0 ? _h : "",
-                        stderr: (_j = ext.stderr) !== null && _j !== void 0 ? _j : "",
-                    });
-                }
-                throw new GraphQLRequestError(msg, {
-                    request: e.request,
-                    response: e.response,
-                    cause: e,
+    }
+    catch (e) {
+        if (e instanceof ClientError) {
+            const msg = e.response.errors?.[0]?.message ?? `API Error`;
+            const ext = e.response.errors?.[0]?.extensions;
+            if (ext?._type === "EXEC_ERROR") {
+                throw new ExecError(msg, {
+                    cmd: ext.cmd ?? [],
+                    exitCode: ext.exitCode ?? -1,
+                    stdout: ext.stdout ?? "",
+                    stderr: ext.stderr ?? "",
                 });
             }
-            // Looking for connection error in case the function has not been awaited.
-            if (e.errno === "ECONNREFUSED") {
-                throw new NotAwaitedRequestError("Encountered an error while requesting data via graphql through a synchronous call. Make sure the function called is awaited.", { cause: e });
-            }
-            // Just throw the unknown error
-            throw new UnknownDaggerError("Encountered an unknown error while requesting data via graphql", { cause: e });
+            throw new GraphQLRequestError(msg, {
+                request: e.request,
+                response: e.response,
+                cause: e,
+            });
+        }
+        // Looking for connection error in case the function has not been awaited.
+        if (e.errno === "ECONNREFUSED") {
+            throw new NotAwaitedRequestError("Encountered an error while requesting data via graphql through a synchronous call. Make sure the function called is awaited.", { cause: e });
         }
-        return queryFlatten(computeQuery);
-    });
+        // Just throw the unknown error
+        throw new UnknownDaggerError("Encountered an unknown error while requesting data via graphql", { cause: e });
+    }
+    return queryFlatten(computeQuery);
 }

package/dist/common/errors/DaggerSDKError.js

@@ -3,9 +3,13 @@ import { log } from "../utils.js";
  * The base error. Every other error inherits this error.
  */
 export class DaggerSDKError extends Error {
+    /**
+     * The original error, which caused the DaggerSDKError.
+     */
+    cause;
     constructor(message, options) {
         super(message);
-        this.cause = options === null || options === void 0 ? void 0 : options.cause;
+        this.cause = options?.cause;
     }
     /**
      * @hidden

package/dist/common/errors/DockerImageRefValidationError.js

@@ -5,13 +5,17 @@ import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
  *  DockerImage constructor.
  */
 export class DockerImageRefValidationError extends DaggerSDKError {
+    name = ERROR_NAMES.DockerImageRefValidationError;
+    code = ERROR_CODES.DockerImageRefValidationError;
+    /**
+     *  The docker image reference, which caused the error.
+     */
+    ref;
     /**
      *  @hidden
      */
     constructor(message, options) {
         super(message, options);
-        this.name = ERROR_NAMES.DockerImageRefValidationError;
-        this.code = ERROR_CODES.DockerImageRefValidationError;
-        this.ref = options === null || options === void 0 ? void 0 : options.ref;
+        this.ref = options?.ref;
     }
 }

package/dist/common/errors/EngineSessionConnectParamsParseError.js

@@ -4,13 +4,17 @@ import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
  * This error is thrown if the EngineSession does not manage to parse the required connection parameters from the session binary
  */
 export class EngineSessionConnectParamsParseError extends DaggerSDKError {
+    name = ERROR_NAMES.EngineSessionConnectParamsParseError;
+    code = ERROR_CODES.EngineSessionConnectParamsParseError;
+    /**
+     *  the line, which caused the error during parsing, if the error was caused because of parsing.
+     */
+    parsedLine;
     /**
      * @hidden
      */
     constructor(message, options) {
         super(message, options);
-        this.name = ERROR_NAMES.EngineSessionConnectParamsParseError;
-        this.code = ERROR_CODES.EngineSessionConnectParamsParseError;
         this.parsedLine = options.parsedLine;
     }
 }

package/dist/common/errors/EngineSessionConnectionTimeoutError.js

@@ -4,13 +4,17 @@ import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
  * This error is thrown if the EngineSession does not manage to parse the required port successfully because the sessions connection timed out.
  */
 export class EngineSessionConnectionTimeoutError extends DaggerSDKError {
+    name = ERROR_NAMES.EngineSessionConnectionTimeoutError;
+    code = ERROR_CODES.EngineSessionConnectionTimeoutError;
+    /**
+     * The duration until the timeout occurred in ms.
+     */
+    timeOutDuration;
     /**
      * @hidden
      */
     constructor(message, options) {
         super(message, options);
-        this.name = ERROR_NAMES.EngineSessionConnectionTimeoutError;
-        this.code = ERROR_CODES.EngineSessionConnectionTimeoutError;
         this.timeOutDuration = options.timeOutDuration;
     }
 }

package/dist/common/errors/EngineSessionErrorOptions.js

@@ -5,12 +5,12 @@ import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
  * This usually happens if no connection can be established.
  */
 export class EngineSessionError extends DaggerSDKError {
+    name = ERROR_NAMES.EngineSessionError;
+    code = ERROR_CODES.EngineSessionError;
     /**
      * @hidden
      */
     constructor(message, options) {
         super(message, options);
-        this.name = ERROR_NAMES.EngineSessionError;
-        this.code = ERROR_CODES.EngineSessionError;
     }
 }

package/dist/common/errors/ExecError.js

@@ -4,13 +4,29 @@ import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
  *  API error from an exec operation in a pipeline.
  */
 export class ExecError extends DaggerSDKError {
+    name = ERROR_NAMES.ExecError;
+    code = ERROR_CODES.ExecError;
+    /**
+     *  The command that caused the error.
+     */
+    cmd;
+    /**
+     *  The exit code of the command.
+     */
+    exitCode;
+    /**
+     * The stdout of the command.
+     */
+    stdout;
+    /**
+     * The stderr of the command.
+     */
+    stderr;
     /**
      *  @hidden
      */
     constructor(message, options) {
         super(message, options);
-        this.name = ERROR_NAMES.ExecError;
-        this.code = ERROR_CODES.ExecError;
         this.cmd = options.cmd;
         this.exitCode = options.exitCode;
         this.stdout = options.stdout;

package/dist/common/errors/GraphQLRequestError.js

@@ -4,13 +4,21 @@ import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
  *  This error originates from the dagger engine. It means that some error was thrown and sent back via GraphQL.
  */
 export class GraphQLRequestError extends DaggerSDKError {
+    name = ERROR_NAMES.GraphQLRequestError;
+    code = ERROR_CODES.GraphQLRequestError;
+    /**
+     *  The query and variables, which caused the error.
+     */
+    requestContext;
+    /**
+     *  the GraphQL response containing the error.
+     */
+    response;
     /**
      *  @hidden
      */
     constructor(message, options) {
         super(message, options);
-        this.name = ERROR_NAMES.GraphQLRequestError;
-        this.code = ERROR_CODES.GraphQLRequestError;
         this.requestContext = options.request;
         this.response = options.response;
     }

package/dist/common/errors/InitEngineSessionBinaryError.js

@@ -4,12 +4,12 @@ import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
  *  This error is thrown if the dagger binary cannot be copied from the dagger docker image and copied to the local host.
  */
 export class InitEngineSessionBinaryError extends DaggerSDKError {
+    name = ERROR_NAMES.InitEngineSessionBinaryError;
+    code = ERROR_CODES.InitEngineSessionBinaryError;
     /**
      *  @hidden
      */
     constructor(message, options) {
         super(message, options);
-        this.name = ERROR_NAMES.InitEngineSessionBinaryError;
-        this.code = ERROR_CODES.InitEngineSessionBinaryError;
     }
 }

package/dist/common/errors/NotAwaitedRequestError.js

@@ -4,12 +4,12 @@ import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
  * This error is thrown when the compute function isn't awaited.
  */
 export class NotAwaitedRequestError extends DaggerSDKError {
+    name = ERROR_NAMES.NotAwaitedRequestError;
+    code = ERROR_CODES.NotAwaitedRequestError;
     /**
      * @hidden
      */
     constructor(message, options) {
         super(message, options);
-        this.name = ERROR_NAMES.NotAwaitedRequestError;
-        this.code = ERROR_CODES.NotAwaitedRequestError;
     }
 }

package/dist/common/errors/TooManyNestedObjectsError.js

@@ -4,13 +4,17 @@ import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
  *  Dagger only expects one response value from the engine. If the engine returns more than one value this error is thrown.
  */
 export class TooManyNestedObjectsError extends DaggerSDKError {
+    name = ERROR_NAMES.TooManyNestedObjectsError;
+    code = ERROR_CODES.TooManyNestedObjectsError;
+    /**
+     *  the response containing more than one value.
+     */
+    response;
     /**
      * @hidden
      */
     constructor(message, options) {
         super(message, options);
-        this.name = ERROR_NAMES.TooManyNestedObjectsError;
-        this.code = ERROR_CODES.TooManyNestedObjectsError;
         this.response = options.response;
     }
 }

package/dist/common/errors/UnknownDaggerError.js

@@ -4,12 +4,12 @@ import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
  *  This error is thrown if the dagger SDK does not identify the error and just wraps the cause.
  */
 export class UnknownDaggerError extends DaggerSDKError {
+    name = ERROR_NAMES.UnknownDaggerError;
+    code = ERROR_CODES.UnknownDaggerError;
     /**
      * @hidden
      */
     constructor(message, options) {
         super(message, options);
-        this.name = ERROR_NAMES.UnknownDaggerError;
-        this.code = ERROR_CODES.UnknownDaggerError;
     }
 }

package/dist/common/errors/errors-codes.js

@@ -40,4 +40,4 @@ export const ERROR_CODES = {
      */
     ExecError: "D109",
 };
-export const ERROR_NAMES = Object.keys(ERROR_CODES).reduce((obj, item) => (Object.assign(Object.assign({}, obj), { [item]: item })), {});
+export const ERROR_NAMES = Object.keys(ERROR_CODES).reduce((obj, item) => ({ ...obj, [item]: item }), {});

package/dist/common/utils.d.ts

@@ -10,8 +10,8 @@ export declare const log: (stack?: string) => {
     isLevelValid(level: "error" | "debug" | "info" | "warn" | "disable" | "success"): boolean;
     isAllowedLevel(level: "error" | "debug" | "info" | "warn" | "disable" | "success"): boolean;
     checkSetting(setting: {
-        reverse?: boolean | undefined;
         bold?: boolean | undefined;
+        reverse?: boolean | undefined;
         italic?: boolean | undefined;
         dim?: boolean | undefined;
         underscore?: boolean | undefined;
@@ -29,16 +29,16 @@ export declare const log: (stack?: string) => {
     reverse(): any;
     italic(): any;
     fontColorLog(ticket: "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white", text: string, setting?: {
-        reverse?: boolean | undefined;
         bold?: boolean | undefined;
+        reverse?: boolean | undefined;
         italic?: boolean | undefined;
         dim?: boolean | undefined;
         underscore?: boolean | undefined;
         strikethrough?: boolean | undefined;
     } | undefined): void;
     bgColorLog(ticket: "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white", text: string, setting?: {
-        reverse?: boolean | undefined;
         bold?: boolean | undefined;
+        reverse?: boolean | undefined;
         italic?: boolean | undefined;
         dim?: boolean | undefined;
         underscore?: boolean | undefined;
@@ -48,8 +48,8 @@ export declare const log: (stack?: string) => {
         font?: ("black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white") | undefined;
         bg?: ("black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white") | undefined;
     }, text: string, setting?: {
-        reverse?: boolean | undefined;
         bold?: boolean | undefined;
+        reverse?: boolean | undefined;
         italic?: boolean | undefined;
         dim?: boolean | undefined;
         underscore?: boolean | undefined;

package/dist/connect.d.ts

@@ -1,33 +1,28 @@
-/// <reference types="node" />
-import { Writable } from "node:stream";
 import { Client } from "./api/client.gen.js";
+import { ConnectOpts } from "./connectOpts.js";
+export type CallbackFct = (client: Client) => Promise<void>;
 /**
- * ConnectOpts defines option used to connect to an engine.
+ * connection executes the given function using the default global Dagger client.
+ *
+ * @example
+ * ```ts
+ * await connection(
+ *   async () => {
+ *     await dag
+ *       .container()
+ *       .from("alpine")
+ *       .withExec(["apk", "add", "curl"])
+ *       .withExec(["curl", "https://dagger.io/"])
+ *       .sync()
+ *   }, { LogOutput: process.stderr }
+ * )
+ * ```
  */
-export interface ConnectOpts {
-    /**
-     * Use to overwrite Dagger workdir
-     * @defaultValue process.cwd()
-     */
-    Workdir?: 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;
-}
+export declare function connection(fct: () => Promise<void>, cfg?: ConnectOpts): Promise<void>;
+/**
+ * Close global client connection
+ */
+export declare function close(): void;
 /**
  * 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,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAEtC,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAG5C;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;;;;;;;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,CA6Cf"}
+{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../connect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAI9C,MAAM,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;AAE3D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EACxB,GAAG,GAAE,WAAgB,iBAKtB;AAED;;GAEG;AACH,wBAAgB,KAAK,SAEpB;AAED;;;;GAIG;AACH,wBAAsB,OAAO,CAC3B,EAAE,EAAE,WAAW,EACf,MAAM,GAAE,WAAgB,GACvB,OAAO,CAAC,IAAI,CAAC,CAiBf"}

package/dist/connect.js

@@ -1,57 +1,51 @@
-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());
-    });
-};
 import { Client } from "./api/client.gen.js";
-import { Bin, CLI_VERSION } from "./provisioning/index.js";
+import { Context, defaultContext } from "./context/context.js";
+import { CLI_VERSION } from "./provisioning/index.js";
+/**
+ * connection executes the given function using the default global Dagger client.
+ *
+ * @example
+ * ```ts
+ * await connection(
+ *   async () => {
+ *     await dag
+ *       .container()
+ *       .from("alpine")
+ *       .withExec(["apk", "add", "curl"])
+ *       .withExec(["curl", "https://dagger.io/"])
+ *       .sync()
+ *   }, { LogOutput: process.stderr }
+ * )
+ * ```
+ */
+export async function connection(fct, cfg = {}) {
+    await defaultContext.connection(cfg);
+    await fct().finally(() => close());
+}
+/**
+ * Close global client connection
+ */
+export function close() {
+    defaultContext.close();
+}
 /**
  * connect runs GraphQL server and initializes a
  * GraphQL client to execute query on it through its callback.
  * This implementation is based on the existing Go SDK.
  */
-export function connect(cb, config = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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");
-            }
-            if (config.Workdir && config.Workdir !== "") {
-                throw new Error("cannot configure workdir for existing session (please use --workdir or host.directory with absolute paths instead)");
-            }
-            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();
-        }
-        // Warning shall be throw if versions are not compatible
-        try {
-            yield client.checkVersionCompatibility(CLI_VERSION);
-        }
-        catch (e) {
-            console.error("failed to check version compatibility:", e);
-        }
-        yield cb(client).finally(() => __awaiter(this, void 0, void 0, function* () {
-            if (close) {
-                close();
-            }
-        }));
+export async function connect(cb, config = {}) {
+    const ctx = new Context();
+    const client = new Client({ ctx: ctx });
+    // Initialize connection
+    await ctx.connection(config);
+    // Warning shall be throw if versions are not compatible
+    try {
+        await client.checkVersionCompatibility(CLI_VERSION);
+    }
+    catch (e) {
+        console.error("failed to check version compatibility:", e);
+    }
+    await cb(client).finally(() => {
+        ctx.close();
     });
 }