@dagger.io/dagger 0.14.0 → 0.15.0

package/dist/src/module/introspector/typescript_module/ast.js

@@ -0,0 +1,254 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { IntrospectionError } from "../../../common/errors/index.js";
+import { isDeclarationOf } from "./declarations.js";
+import { getValueByExportedName } from "./explorer.js";
+export const CLIENT_GEN_FILE = "client.gen.ts";
+export class AST {
+    files;
+    userModule;
+    checker;
+    sourceFiles;
+    constructor(files, userModule) {
+        this.files = files;
+        this.userModule = userModule;
+        const program = ts.createProgram(files, {
+            experimentalDecorators: true,
+            moduleResolution: ts.ModuleResolutionKind.Node10,
+            target: ts.ScriptTarget.ES2022,
+        });
+        this.checker = program.getTypeChecker();
+        this.sourceFiles = program
+            .getSourceFiles()
+            .filter((file) => !file.isDeclarationFile);
+    }
+    findResolvedNodeByName(name, 
+    /**
+     * Optionally look for a specific node kind if we already know
+     * what we're looking for.
+     */
+    kind) {
+        let result;
+        for (const sourceFile of this.sourceFiles) {
+            ts.forEachChild(sourceFile, (node) => {
+                if (result !== undefined)
+                    return;
+                // Skip if it's not from the client gen nor the user module
+                if (!sourceFile.fileName.endsWith(CLIENT_GEN_FILE) &&
+                    !this.files.includes(sourceFile.fileName)) {
+                    return;
+                }
+                if (kind !== undefined && node.kind === kind) {
+                    const isDeclarationValid = isDeclarationOf[kind](node);
+                    if (!isDeclarationValid)
+                        return;
+                    const convertedNode = node;
+                    if (!convertedNode.name || convertedNode.name.getText() !== name) {
+                        return;
+                    }
+                    const symbol = this.checker.getSymbolAtLocation(convertedNode.name);
+                    if (!symbol) {
+                        console.debug(`missing symbol for ${name} at ${sourceFile.fileName}:${node.pos}`);
+                        return;
+                    }
+                    result = {
+                        type: kind,
+                        node: convertedNode,
+                        symbol: symbol,
+                        file: sourceFile,
+                    };
+                }
+            });
+        }
+        return result;
+    }
+    getTypeFromTypeAlias(typeAlias) {
+        const symbol = this.getSymbolOrThrow(typeAlias.name);
+        return this.checker.getDeclaredTypeOfSymbol(symbol);
+    }
+    static getNodePosition(node) {
+        const sourceFile = node.getSourceFile();
+        const position = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart());
+        return `${sourceFile.fileName}:${position.line}:${position.character}`;
+    }
+    getDocFromSymbol(symbol) {
+        return ts.displayPartsToString(symbol.getDocumentationComment(this.checker));
+    }
+    getSymbolOrThrow(node) {
+        const symbol = this.getSymbol(node);
+        if (!symbol) {
+            throw new IntrospectionError(`could not find symbol at ${AST.getNodePosition(node)}`);
+        }
+        return symbol;
+    }
+    getSignatureFromFunctionOrThrow(node) {
+        const signature = this.checker.getSignatureFromDeclaration(node);
+        if (!signature) {
+            throw new IntrospectionError(`could not find signature at ${AST.getNodePosition(node)}`);
+        }
+        return signature;
+    }
+    getSymbol(node) {
+        return this.checker.getSymbolAtLocation(node);
+    }
+    isNodeDecoratedWith(node, daggerDecorator) {
+        const decorators = ts.getDecorators(node);
+        if (!decorators) {
+            return false;
+        }
+        const decorator = decorators.find((d) => d.expression.getText().startsWith(daggerDecorator));
+        if (!decorator) {
+            return false;
+        }
+        if (!ts.isCallExpression(decorator.expression)) {
+            throw new IntrospectionError(`decorator at ${AST.getNodePosition(node)} should be a call expression, please use ${daggerDecorator}() instead.`);
+        }
+        return true;
+    }
+    getDecoratorArgument(node, daggerDecorator, type, position = 0) {
+        const decorators = ts.getDecorators(node);
+        if (!decorators) {
+            return undefined;
+        }
+        const decorator = decorators.find((d) => d.expression.getText().startsWith(daggerDecorator));
+        if (!decorator) {
+            return undefined;
+        }
+        const argument = decorator.expression.arguments[position];
+        if (!argument) {
+            return undefined;
+        }
+        switch (type) {
+            case "string":
+                return argument.getText();
+            case "object":
+                return eval(`(${argument.getText()})`);
+        }
+    }
+    unwrapTypeStringFromPromise(type) {
+        if (type.startsWith("Promise<")) {
+            return type.slice("Promise<".length, -">".length);
+        }
+        if (type.startsWith("Awaited<")) {
+            return type.slice("Awaited<".length, -">".length);
+        }
+        return type;
+    }
+    unwrapTypeStringFromArray(type) {
+        if (type.endsWith("[]")) {
+            return type.replace("[]", "");
+        }
+        if (type.startsWith("Array<")) {
+            return type.slice("Array<".length, -">".length);
+        }
+        return type;
+    }
+    stringTypeToUnwrappedType(type) {
+        type = this.unwrapTypeStringFromPromise(type);
+        // If they are difference, that means we upwrapped the array.
+        const extractedTypeFromArray = this.unwrapTypeStringFromArray(type);
+        if (extractedTypeFromArray !== type) {
+            return this.stringTypeToUnwrappedType(extractedTypeFromArray);
+        }
+        return type;
+    }
+    typeToStringType(type) {
+        const stringType = this.checker.typeToString(type);
+        return this.stringTypeToUnwrappedType(stringType);
+    }
+    tsTypeToTypeDef(node, type) {
+        if (type.flags & ts.TypeFlags.String)
+            return { kind: TypeDefKind.StringKind };
+        if (type.flags & ts.TypeFlags.Number)
+            return { kind: TypeDefKind.IntegerKind };
+        if (type.flags & ts.TypeFlags.Boolean)
+            return { kind: TypeDefKind.BooleanKind };
+        if (type.flags & ts.TypeFlags.Void)
+            return { kind: TypeDefKind.VoidKind };
+        // If a type has a flag Object, is can basically be anything.
+        // We firstly wants to see if it's a promise or an array so we can unwrap the
+        // actual type.
+        if (type.flags & ts.TypeFlags.Object) {
+            const objectType = type;
+            // If it's a reference, that means it's a generic type like
+            // `Promise<T>` or `number[]` or `Array<T>`.
+            if (objectType.objectFlags & ts.ObjectFlags.Reference) {
+                const typeArguments = this.checker.getTypeArguments(type);
+                switch (typeArguments.length) {
+                    case 0:
+                        // Might change after to support more complex type
+                        break;
+                    case 1: {
+                        const typeArgument = typeArguments[0];
+                        if (type.symbol.getName() === "Promise") {
+                            return this.tsTypeToTypeDef(node, typeArgument);
+                        }
+                        if (type.symbol.getName() === "Array") {
+                            return {
+                                kind: TypeDefKind.ListKind,
+                                typeDef: this.tsTypeToTypeDef(node, typeArgument),
+                            };
+                        }
+                        return undefined;
+                    }
+                    default: {
+                        throw new IntrospectionError(`could not resolve type ${type.symbol.getName()} at ${AST.getNodePosition(node)}, dagger does not support generics with argument yet.`);
+                    }
+                }
+            }
+        }
+    }
+    resolveParameterDefaultValueTypeReference(expression, value) {
+        const type = typeof value;
+        switch (type) {
+            case "string":
+            case "number":
+            case "bigint":
+            case "boolean":
+            case "object":
+                // Value will be jsonified on registration.
+                return value;
+            default:
+                // If we cannot resolve the value, we skip it and let the value be resolved automatically by the runtime
+                return undefined;
+        }
+    }
+    resolveParameterDefaultValue(expression) {
+        const kind = expression.kind;
+        switch (kind) {
+            case ts.SyntaxKind.StringLiteral:
+                return `${eval(expression.getText())}`;
+            case ts.SyntaxKind.NumericLiteral:
+                return parseInt(expression.getText());
+            case ts.SyntaxKind.TrueKeyword:
+                return true;
+            case ts.SyntaxKind.FalseKeyword:
+                return false;
+            case ts.SyntaxKind.NullKeyword:
+                return null;
+            case ts.SyntaxKind.ArrayLiteralExpression:
+                return eval(expression.getText());
+            case ts.SyntaxKind.Identifier: {
+                // If the parameter is a reference to a variable, we try to resolve it using
+                // exported modules value.
+                const value = getValueByExportedName(expression.getText(), this.userModule);
+                if (value === undefined) {
+                    throw new IntrospectionError(`could not resolve default value reference to the variable: '${expression.getText()}' from ${AST.getNodePosition(expression)}. Is it exported by the module?`);
+                }
+                return this.resolveParameterDefaultValueTypeReference(expression, value);
+            }
+            case ts.SyntaxKind.PropertyAccessExpression: {
+                const accessors = expression.getText().split(".");
+                let value = getValueByExportedName(accessors[0], this.userModule);
+                for (let i = 1; i < accessors.length; i++) {
+                    value = value[accessors[i]];
+                }
+                return this.resolveParameterDefaultValueTypeReference(expression, value);
+            }
+            default: {
+                console.warn(`default value '${expression.getText()}' at ${AST.getNodePosition(expression)} cannot be resolved, dagger does not support object or function as default value. 
+          The value will be ignored by the introspection and resolve at the runtime.`);
+            }
+        }
+    }
+}

package/dist/src/module/introspector/typescript_module/declarations.d.ts

@@ -0,0 +1,15 @@
+import ts from "typescript";
+export type DeclarationsMap = {
+    [ts.SyntaxKind.ClassDeclaration]: ts.ClassDeclaration;
+    [ts.SyntaxKind.MethodDeclaration]: ts.MethodDeclaration;
+    [ts.SyntaxKind.PropertyDeclaration]: ts.PropertyDeclaration;
+    [ts.SyntaxKind.FunctionDeclaration]: ts.FunctionDeclaration;
+    [ts.SyntaxKind.EnumDeclaration]: ts.EnumDeclaration;
+    [ts.SyntaxKind.InterfaceDeclaration]: ts.InterfaceDeclaration;
+    [ts.SyntaxKind.TypeAliasDeclaration]: ts.TypeAliasDeclaration;
+};
+export type Declarations<T extends ts.SyntaxKind> = T extends keyof DeclarationsMap ? DeclarationsMap[T] : ts.Node;
+export declare const isDeclarationOf: {
+    [K in keyof DeclarationsMap]: (node: ts.Node) => node is DeclarationsMap[K];
+};
+//# sourceMappingURL=declarations.d.ts.map

package/dist/src/module/introspector/typescript_module/declarations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declarations.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/typescript_module/declarations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,MAAM,MAAM,eAAe,GAAG;IAC5B,CAAC,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAA;IACrD,CAAC,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAA;IACvD,CAAC,EAAE,CAAC,UAAU,CAAC,mBAAmB,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAA;IAC3D,CAAC,EAAE,CAAC,UAAU,CAAC,mBAAmB,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAA;IAC3D,CAAC,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE,EAAE,CAAC,eAAe,CAAA;IACnD,CAAC,EAAE,CAAC,UAAU,CAAC,oBAAoB,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAA;IAC7D,CAAC,EAAE,CAAC,UAAU,CAAC,oBAAoB,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAA;CAC9D,CAAA;AAED,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,EAAE,CAAC,UAAU,IAC9C,CAAC,SAAS,MAAM,eAAe,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,IAAI,CAAA;AAEhE,eAAO,MAAM,eAAe,EAAE;KAC3B,CAAC,IAAI,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,IAAI,IAAI,eAAe,CAAC,CAAC,CAAC;CAS5E,CAAA"}

package/dist/src/module/introspector/typescript_module/declarations.js

@@ -0,0 +1,10 @@
+import ts from "typescript";
+export const isDeclarationOf = {
+    [ts.SyntaxKind.ClassDeclaration]: ts.isClassDeclaration,
+    [ts.SyntaxKind.MethodDeclaration]: ts.isMethodDeclaration,
+    [ts.SyntaxKind.PropertyDeclaration]: ts.isPropertyDeclaration,
+    [ts.SyntaxKind.FunctionDeclaration]: ts.isFunctionDeclaration,
+    [ts.SyntaxKind.EnumDeclaration]: ts.isEnumDeclaration,
+    [ts.SyntaxKind.InterfaceDeclaration]: ts.isInterfaceDeclaration,
+    [ts.SyntaxKind.TypeAliasDeclaration]: ts.isTypeAliasDeclaration,
+};

package/dist/src/module/introspector/typescript_module/explorer.d.ts

@@ -0,0 +1,4 @@
+import Module from "node:module";
+export declare function findModuleByExportedName(name: string, modules: Module[]): Module | undefined;
+export declare function getValueByExportedName(name: string, modules: Module[]): any;
+//# sourceMappingURL=explorer.d.ts.map

package/dist/src/module/introspector/typescript_module/explorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explorer.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/typescript_module/explorer.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,aAAa,CAAA;AAEhC,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EAAE,GAChB,MAAM,GAAG,SAAS,CAMpB;AAGD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,GAAG,CAQ3E"}

package/dist/src/module/introspector/typescript_module/explorer.js

@@ -0,0 +1,16 @@
+export function findModuleByExportedName(name, modules) {
+    for (const module of modules) {
+        if (module[name]) {
+            return module;
+        }
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getValueByExportedName(name, modules) {
+    for (const module of modules) {
+        if (module[name]) {
+            return module[name];
+        }
+    }
+    return undefined;
+}

package/dist/src/module/introspector/typescript_module/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ast.js";
+export * from "./explorer.js";
+export * from "./typedef_utils.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/module/introspector/typescript_module/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/typescript_module/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA;AAC7B,cAAc,oBAAoB,CAAA"}

package/dist/src/module/introspector/typescript_module/index.js

@@ -0,0 +1,3 @@
+export * from "./ast.js";
+export * from "./explorer.js";
+export * from "./typedef_utils.js";

package/dist/src/module/introspector/typescript_module/typedef_utils.d.ts

@@ -0,0 +1,5 @@
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { TypeDef } from "../typedef.js";
+export declare function isTypeDefResolved(typeDef: TypeDef<TypeDefKind>): boolean;
+export declare function resolveTypeDef(typeDef: TypeDef<TypeDefKind> | undefined, reference: TypeDef<TypeDefKind>): TypeDef<TypeDefKind>;
+//# sourceMappingURL=typedef_utils.d.ts.map

package/dist/src/module/introspector/typescript_module/typedef_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedef_utils.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/typescript_module/typedef_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAExD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAEvC,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,OAAO,CAgBxE;AAED,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,SAAS,EACzC,SAAS,EAAE,OAAO,CAAC,WAAW,CAAC,GAC9B,OAAO,CAAC,WAAW,CAAC,CAetB"}

package/dist/src/module/introspector/typescript_module/typedef_utils.js

@@ -0,0 +1,26 @@
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { IntrospectionError } from "../../../common/errors/index.js";
+export function isTypeDefResolved(typeDef) {
+    if (typeDef.kind !== TypeDefKind.ListKind) {
+        return true;
+    }
+    const arrayTypeDef = typeDef;
+    if (arrayTypeDef.typeDef === undefined) {
+        return false;
+    }
+    if (arrayTypeDef.typeDef.kind === TypeDefKind.ListKind) {
+        return isTypeDefResolved(arrayTypeDef.typeDef);
+    }
+    return true;
+}
+export function resolveTypeDef(typeDef, reference) {
+    if (typeDef === undefined) {
+        return reference;
+    }
+    if (typeDef.kind === TypeDefKind.ListKind) {
+        const listTypeDef = typeDef;
+        listTypeDef.typeDef = resolveTypeDef(listTypeDef.typeDef, reference);
+        return listTypeDef;
+    }
+    throw new IntrospectionError(`type ${JSON.stringify(typeDef)} has already been resolved, it should not be overwritten ; reference: ${JSON.stringify(reference)}`);
+}

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

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

package/dist/{introspector → src/module/introspector}/utils/files.js

@@ -20,7 +20,7 @@ export async function listFiles(dir = ".") {
         }
         const ext = path.extname(filepath);
         if (allowedExtensions.find((allowedExt) => allowedExt === ext)) {
-            return [`${dir}/${file}`];
+            return [path.join(dir, file)];
         }
         return [];
     }));

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":"AAKA,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;;;;;;;;;;;;;GAaG;AACH,qBAAa,QAAQ;IACnB;;;OAGG;IACH,MAAM,QAAO,CAAC,CAAC,CAAe,SAAL,KAAK,EAAE,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,CAMpD;IAED;;;OAGG;IACH,QAAQ,QAAO,CAAC,CAAC,CAAe,SAAL,KAAK,EAAE,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,CAItD;IAED;;;;;;OAMG;IACH,KAAK,WAAY,MAAM,KAAG,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC,CAIxE;IAED;;;OAGG;IACH,IAAI,WACM,MAAM,KACb,CAAC,CACF,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,MAAM,EAC5B,UAAU,CAAC,EAAE,kBAAkB,KAC5B,IAAI,CAAC,CAMT;IAED,QAAQ,UACC,eAAe,KACrB,CAAC,CACF,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,KACnB,IAAI,CAAC,CAET;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/{introspector/registry → src/module}/registry.js

@@ -3,7 +3,7 @@
 // @experimentalDecorators
 // @emitDecoratorMetadata
 import "reflect-metadata";
-import { UnknownDaggerError } from "../../common/errors/UnknownDaggerError.js";
+import { UnknownDaggerError } from "../common/errors/index.js";
 /**
  * Registry stores class and method that have the @object decorator.
  *

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/{provisioning → src/provisioning}/bin.js

@@ -11,7 +11,7 @@ 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 "../graphql/client.js";
+import { createGQLClient } from "../common/graphql/client.js";
 const CLI_HOST = "dl.dagger.io";
 let OVERRIDE_CLI_URL;
 let OVERRIDE_CHECKSUMS_URL;

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

@@ -0,0 +1,2 @@
+export declare const CLI_VERSION = "0.15.0";
+//# 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/{provisioning → src/provisioning}/default.js

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

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

@@ -0,0 +1,30 @@
+import { GraphQLClient } from "graphql-request";
+import { Writable } from "node:stream";
+export interface ConnectOpts {
+    Workdir?: string;
+    Project?: string;
+    LogOutput?: Writable;
+    Timeout?: number;
+}
+export interface ConnectParams {
+    port: number;
+    session_token: string;
+}
+export interface EngineConn {
+    /**
+     * Library connection provisioning, it returns a ready to use GraphQL client
+     * connected to the Dagger engine.
+     *
+     * This test multiple options to connect to the Dagger Engine.
+     * 1. Check for already running engine through `DAGGER_SESSION_PORT` & `DAGGER_SESSION_TOKEN`
+     * environment variable.
+     * 2. Auto provision the engine from the Dagger CLI (install it if it doesn't exist) and
+     * connect the client.
+     */
+    Connect: (opts: ConnectOpts) => Promise<GraphQLClient>;
+    /**
+     * Close stops the current connection.
+     */
+    Close: () => void;
+}
+//# sourceMappingURL=engineconn.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engineconn.d.ts","sourceRoot":"","sources":["../../../src/provisioning/engineconn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,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,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,UAAU;IACzB;;;;;;;;;OASG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC,aAAa,CAAC,CAAA;IAEtD;;OAEG;IACH,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB"}

package/dist/src/provisioning/engineconn.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+import { GraphQLClient } from "graphql-request";
+import { ConnectOpts } from "../connectOpts.js";
+export declare function withEngineSession<T>(connectOpts: ConnectOpts, cb: (gqlClient: GraphQLClient) => Promise<T>): Promise<T>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/provisioning/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE/C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAI/C,wBAAsB,iBAAiB,CAAC,CAAC,EACvC,WAAW,EAAE,WAAW,EACxB,EAAE,EAAE,CAAC,SAAS,EAAE,aAAa,KAAK,OAAO,CAAC,CAAC,CAAC,GAC3C,OAAO,CAAC,CAAC,CAAC,CAYZ"}

package/dist/src/provisioning/index.js

@@ -0,0 +1,14 @@
+import { Bin } from "./bin.js";
+import { CLI_VERSION } from "./default.js";
+export async function withEngineSession(connectOpts, cb) {
+    const cliBin = process.env["_EXPERIMENTAL_DAGGER_CLI_BIN"];
+    const engineConn = new Bin(cliBin, CLI_VERSION);
+    const gqlClient = await engineConn.Connect(connectOpts);
+    try {
+        const res = await cb(gqlClient);
+        return res;
+    }
+    finally {
+        await engineConn.Close();
+    }
+}

package/dist/src/telemetry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/telemetry/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C,OAAO,EAAE,SAAS,EAAE,CAAA"}

package/dist/src/telemetry/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/telemetry/init.ts"],"names":[],"mappings":"AAcA;;GAEG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,aAAa,CAAQ;IAE7B,OAAO,CAAC,GAAG,CAAC,CAAS;IAErB;;OAEG;IACH,UAAU;IAQV,SAAS;IAoBT;;OAEG;IACG,KAAK;IAMX;;OAEG;IACH,QAAQ;CAeT"}

package/dist/src/telemetry/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../../../src/telemetry/telemetry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAGnD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAMpC,wBAAgB,UAAU,SAEzB;AAED,wBAAsB,KAAK,kBAE1B;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,SAAqB,GAAG,MAAM,CAG3D;AAED,wBAAgB,UAAU,0BAgBzB"}

package/dist/src/telemetry/tracer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracer.d.ts","sourceRoot":"","sources":["../../../src/telemetry/tracer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;GAEG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAsB;gBAExB,IAAI,EAAE,MAAM;IAIjB,SAAS,CACd,IAAI,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,aAAa,CAAC,UAAU,GACpC,aAAa,CAAC,IAAI;IAIrB;;;;;;;;;;;;;;;;;;;;OAoBG;IACU,eAAe,CAAC,CAAC,EAC5B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,CAAC,IAAI,EAAE,aAAa,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,EAC5C,UAAU,CAAC,EAAE,aAAa,CAAC,UAAU;CAoBxC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dagger.io/dagger",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "author": "hello@dagger.io",
   "license": "Apache-2.0",
   "types": "./dist/index.d.ts",
@@ -9,13 +9,13 @@
     "dist/"
   ],
   "exports": {
-    ".": "./dist/index.js",
-    "./telemetry": "./dist/telemetry/index.js"
+    ".": "./dist/src/index.js",
+    "./telemetry": "./dist/src/telemetry/index.js"
   },
   "engines": {
     "node": ">=18"
   },
-  "main": "dist/index.js",
+  "main": "dist/src/index.js",
   "dependencies": {
     "@grpc/grpc-js": "^1.11.1",
     "@lifeomic/axios-fetch": "^3.1.0",
@@ -63,6 +63,7 @@
     "mocha": "^10.7.0",
     "prettier": "^3.3.3",
     "ts-node": "^10.9.2",
+    "tsx": "^4.19.2",
     "typescript-eslint": "^8.0.1"
   }
 }