#github-feed

1 messages · Page 22 of 1

vivid lintelBOT
ornate vigilBOT
#
alexcb
[dagger/dagger] New comment on discussion #13044: git lockfile and content digest caching

Thanks for the suggestion @grouville, I gave it a try under https://github.com/dagger/dagger/pull/12922/changes/0fb4d41a03569731d1eab65ca11241a86940d56f and it seems to be working.

But that seems safer than accidentally reusing a checkout when kept .git state / tags actually changed the result.

erring on the side of safety feels good, especially since this rebase is rather large. Maybe we could come back to it later if we really want to.

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Pull request opened: #13047 core: include module variants in function cache identity

Summary

Fixes #13046 by making the module implementation-scoped cache identity include the AsModuleVariantDigest computed by moduleSource.asModule. Toolchain constructor customization defaults are part of that variant digest, so changing a default from alpha to beta now gives omitted-argument calls a distinct function cache key.

The change also persists AsModuleVariantDigest in the module payload so imported persisted modules keep the same variant-sensitive identity.

Testin...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #13051 Workspace.path does not always return the workspace path

Problem

Workspace.path should return the path of the detected workspace. Today, in some cases, it returns the path where workspace detection started.

Repro:

cd PATH/TO/WORKSPACE/subdir
dagger core current-workspace path
# actual: subdir
# expected: . or the detected workspace path

This is inconsistent with:

dagger core current-workspace directory --path=.

which loads the detected workspace, not subdir.

Likely cause: core/workspace/detect.go sets Path from...

vivid lintelBOT
#
shykes
[dagger/dagger] Pull request opened: #13052 core: add workspace cwd API

Fixes #13051.

Summary

Workspace.path now always reports the detected workspace path. The directory where detection started is stored separately and exposed through Workspace.cwd.

This adds WorkspaceCwd.path, WorkspaceCwd.directory, and WorkspaceCwd.file. Relative paths on those fields resolve from the current working directory within the workspace; absolute paths still resolve from the workspace boundary.

The change also keeps nested uninitialized workspace flows coherent: `w...

vivid lintelBOT
#
shykes
[dagger/dagger] Pull request opened: #13053 core: resolve Workspace file APIs from workspace root

Refs #13051.

Summary

Workspace.file and Workspace.directory now resolve relative paths from the workspace directory, not from the nested cwd where workspace detection started.

This is intentionally narrower than fixing Workspace.path on main. The public Workspace.path behavior is left unchanged for now, while Workspace carries an internal filesystem path base for the file and directory APIs.

For remote rootfs-backed workspaces, the internal filesystem path includes the dete...

vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #13054 Let container commands inherit a workspace

Let container commands inherit a workspace

Problem

When a command runs inside a Dagger container and opens its own Dagger connection, the inner client detects its workspace from the container filesystem.

That is often the wrong workspace.

Here, "workspace" means the Workspace object selected by the outer caller: its source, config, lock state, and module layout.

For example, ../dagger_e2e-helm/e2e/helm/helm_test.go runs as a Go test suite, and the tests use the Dagger SDK:

ornate vigilBOT
#
kinthaiofficial
[dagger/dagger] New comment on discussion #1877: Enforce policies with hooks / middleware

Enforcing policies with hooks/middleware in Dagger pipelines is an important enterprise feature — you want guardrails that apply consistently across all pipelines without requiring each pipeline author to implement them.

The use cases:

  • Security: no container images from untrusted registries
  • Compliance: all builds must produce a SBOM, all containers must be signed
  • Cost: pipelines above a certain complexity require manager approval
  • Quality: no deployments to production without pass...
ornate vigilBOT
#
kinthaiofficial
[dagger/dagger] New comment on discussion #209: Proposal: Dagger Attributes

Dagger Attributes as a concept makes sense — it's the missing metadata layer that lets functions declare capabilities and constraints without baking them into the type system.

A few use cases where attributes would shine:

1. Cache invalidation hints:

// @cache: content-addressable (invalidate only when inputs change)
// @cache: none (always re-run, e.g. for fetching external state)
// @cache: time-based (invalidate after N hours)
func (m *Module) BuildImage(src *Directory) *Contai...
vivid lintelBOT
ornate vigilBOT
#
sam1357
[dagger] New discussion #13055: Dagger develop running `go mod tidy`

Hi there!

We're currently using Dagger extensively in our company's pipelines. On some of our monolithic repositories that hold our modules, we've committed codegen and also have additional checks to verify that the codegen is in sync for a given PR.

A recent change in Dagger has seemingly made it such that dagger develop will introduce changes to go.mod and go.sum if there are upstream dependency updates. For us, this doesn't feel quite ideal as it can lead to polluting PRs with ...

vivid lintelBOT
ornate vigilBOT
#
eunomie
[dagger/dagger] New comment on discussion #13055: Dagger develop running `go mod tidy`

we've committed codegen and also have additional checks to verify that the codegen is in sync for a given PR

We are working toward this goal, as natively supported: push to have codegen files committed (and used at runtime), migrating from dagger develop to dagger generate and generate functions will automatically come with built-in check. That to say what your doing will be the default way to deal with modules.

With that, maybe we can simply not run the go mod tidy in more ...

ornate vigilBOT
#
TomChv
[dagger/dagger] New comment on discussion #13055: Dagger develop running `go mod tidy`

We are working toward this goal, as natively supported: push to have codegen files committed (and used at runtime), migrating from dagger develop to dagger generate and generate functions will automatically come with built-in check. That to say what your doing will be the default way to deal with modules.

I'm happy to see that our ideas around codegen make sense for others too 🚀

With that, maybe we can simply not run the go mod tidy in more cases. Right now, during a develop the ex...

vivid lintelBOT
#
tmablunar
[dagger/dagger] Issue opened: #13056 🐞 Go SDK codegen fails on private transitive Go module deps since v0.20.4

What is the issue?

Dagger v0.20.4+ fails to load any Go-based Dagger module whose go.mod has a private transitive Go dependency (github.com/org/private/libs).

The failure happens during SDK codegen

Might have been introduced in #11826

Works on v0.20.3

Dagger version

v0.20.4

Steps to reproduce

Create a dagger module using go with a dependency on a private go library

{
"name": "test-module",
"engineVersion": "v0.20.4",
"sdk": {
"source": "go",
"config": {
...

vivid lintelBOT
#
TomChv
[dagger/dagger] Pull request opened: #13058 feat(typescript): generate typescript static entrypoint

Summary

Adds a statically generated __dagger.entrypoint.ts for the TypeScript SDK,
mirroring Go's dagger.gen.go. The file is emitted at the module root by
dagger develop and imports the user's classes directly — replacing the
runtime AST + reflection dispatch path with a flat switch(parentName) → switch(fnName) that the engine can jump straight into.

Design doc: design/typescript-module-entrypoint.md.

What changes

  • New emitter `sdk/typescript/src/module/i...
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #13059 dagger toolchain uninstall fails when local toolchain source is missing

Summary

dagger toolchain uninstall fails if the registered toolchain points at a local source path that no longer exists. In that state, uninstall should still be able to remove the toolchain registration instead of trying to resolve/load the missing source first.

Reproduction

From a Dagger repo with a local helm toolchain registered at ./toolchains/helm-dev:

  1. Remove the local source directory:

    rm -rf ./toolchains/helm-dev

  2. Try to uninstall the toolch...

#
grouville
[dagger/dagger] Issue opened: #13060 Regression: `Service.Endpoint` can diverge from `WithServiceBinding` for `PRIVATE`-cache-backed services

Short version

This used to work on v0.20.6. On current main, it does not: a service with a PRIVATE cache mount can resolve to different hostnames through Service.Endpoint and WithServiceBinding.

Theseus made this visible: some checks start a local/dev engine or an SDK runtime, then connect a client to it.

The concrete bug is this: a lazy service graph with a CacheSharingModePrivate cache volume can get a fresh dagql privateNonce on each evaluation. Since service runtime id...

vivid lintelBOT
vivid lintelBOT
#
grouville
[dagger/dagger] Pull request opened: #13061 cache: stabilize private cache identity

Fixes #13060

Why

PRIVATE cache mounts are supposed to isolate cache contents. They should not make the same lazy graph resolve to different service identities each time it is evaluated.

After the dagql cache migration, service hostnames are derived from the resolved graph. That made the old privateNonce behavior visible: every evaluation of a PRIVATE cache volume injected fresh identity into the graph.

So a service like this could split:

srv := dag.Containe...
ornate vigilBOT
#
sam1357
[dagger/dagger] New comment on discussion #13055: Dagger develop running `go mod tidy`

Thanks both! Just wanted to also point out that my initial speculation for go mod tidy causing dependencies to be upgraded was incorrect, it's actually a go get -u that runs within the Dagger develop that is causing those. Is there any intention in keeping this behaviour when running develop?

That to say what your doing will be the default way to deal with modules.

Glad to hear that this will become a natively supported pattern though! It will simplify a lot of our existing ...

vivid lintelBOT
#
shykes
[dagger/dagger] Pull request opened: #13062 Refactor release version generation

Summary

  • remove Changie .changes/.next from version computation

  • compute dev versions from latest stable v* git tag with a patch bump

  • split release target-version regeneration into individual @generate functions

  • update release checklist to run plain dagger generate

Verification

  • dagger --progress=plain generate -l
  • dagger --progress=plain call -m version next-patch-version
  • dagger --progress=plain call -m version version
  • go test . in version, toolchains/cli-dev, toolchains...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #13064 Workspace.git()

Problem

Workspace-aware modules often need local git facts about the workspace they are operating on: HEAD, commit metadata, semver tags, and whether the worktree has uncommitted changes. Today there is no small workspace-scoped API for that.

The available option is GitRepository, which is a broad, remote-oriented git API. Using it for local workspace state leaks more model than callers need and can bring along extra behavior and perf risk. Some callers work around this by passing sepa...

vivid lintelBOT
vivid lintelBOT
#
applejag
[dagger/dagger] Issue opened: #13066 ✨ Allow overriding `StatefulSet.spec.replicas` in the Helm chart

What are you trying to do?

Run multiple Dagger engines in parallel in Kubernetes using StatefulSet, such as multiple across nodes

https://github.com/dagger/dagger/blob/82a4227c793d25566029a27676e8fa7abff80e68/helm/dagger/templates/engine-statefulset.yaml#L11-L14

Want to have some setting in the Helm chart to override this. For example:

engine:
  statefulSet:
    replicas: 1

Why is this important to you?

Parallelizing execution by selecting a different statefulset pod...

vivid lintelBOT
#
shykes
[dagger/dagger] Pull request opened: #13067 docs: propose docs-dev reference generation breakouts

Summary

Moves the docs-dev reference generation breakout proposals onto a clean branch based on latest main.

This PR contains planning docs for:

  • CLI reference generation via an importable Cobra command tree and a reusable Cobra docs generator
  • GraphQL reference generation via live engine service introspection and a reusable SpectaQL module
  • JSON schema reference generation via source-adjacent go:generate declarations

Notes

This is documentation only. It does not change gene...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
grouville
[dagger/dagger] Pull request opened: #13071 fix(toolchains): use locked caches for nested runtimes

The dagql cache migration exposed a bad interaction between PRIVATE cache mounts and lazy service identity. PRIVATE currently injects a fresh dagql cache key input, so a service can resolve one hostname through Endpoint and another through WithServiceBinding.

This change does not remove or redesign PRIVATE. It is a small internal unblocker for the dev runtime paths that hit the issue today.

I verified this in a temporary worktree by building the engine with ./hack/dev and ru...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
vito
[dagger/dagger] Pull request opened: #13073 tui: tests UI

Been working on better support for tests in the Cloud UI - this PR adds the TUI equivalent, pulling logic down into dagui where it'll be shared between them.

TODO:

  • [ ] Automatically enter tests UI when tests are detected?
  • [ ] Integrate with dagger check - what happens when multiple checks produce tests?

Along the way:

  • Prevent zeroing out ChildCount; fixes incremental loading for traces with >100k spans. With this zeroing out you could get a trace that only had the top...
vivid lintelBOT
#
shykes
[dagger/dagger] Pull request opened: #13074 core: add Workspace.git API

Summary

  • add Workspace.git and the new WorkspaceGit object for workspace-local git state
  • add GitRef.committedAt
  • expose head, uncommitted, latestSemverTag, and currentSemverTag
  • explicitly reject git worktrees for the first pass instead of expanding the workspace boundary
  • regenerate GraphQL docs and SDK bindings

Fixes #13064.

Tests

  • git diff --check
  • GOCACHE=/tmp/go-build go test ./core/workspace
  • `GOOS=linux GOARCH=amd64 GOCACHE=/tmp/go-build go test -c ...
vivid lintelBOT
vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13076 cli: preserve local no-color after telemetry init

Nested Dagger commands can run with their own process-level presentation settings even when they inherit OpenTelemetry baggage from a parent command. In particular, TestDaggerUp starts an inner dagger CLI with NO_COLOR=true and DAGGER_PROGRESS=logs so it can parse the tunnel log line that contains the random host port.

telemetry.Init extracts trace context and baggage from the environment. When inherited baggage is present, OpenTelemetry baggage extraction replaces the baggage already on t...

vivid lintelBOT
vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13077 core: expose vault dev service port in secret provider tests

The Vault secret provider helper starts hashicorp/vault:1.18 as a Dagger service and then talks to it on port 8200. That image has OCI EXPOSE metadata for 8200/tcp, but Dagger does not currently promote image EXPOSE metadata into Container.Ports for service healthchecks or service port introspection.

This matches the existing note in core/integration/container_test.go around line 4831: after Import or container.From, ports can show up under image config, but do not actually get set up as D...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13078 toolchains: bump dev engine runc to v1.4.2

We have been investigating rare CI hangs where engine work appeared to stall behind container execution. The strongest captured evidence was not a dagql cache or Directory.Entries deadlock: the goroutine dump showed Dagger blocked inside go-runc's monitor wait for a runc run, while ps output showed the corresponding runc process still alive and its .init child stuck as a zombie.

That zombie process was the key breadcrumb. It pointed the investigation away from Dagger dependency trave...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #13079 chore: bump the sdk-java group in /sdk/java with 4 updates

Bumps the sdk-java group in /sdk/java with 4 updates: com.fasterxml.jackson:jackson-bom, io.smallrye:smallrye-graphql-client-api, io.smallrye:smallrye-graphql-client-implementation-vertx and com.palantir.javapoet:javapoet.

Updates com.fasterxml.jackson:jackson-bom from 2.21.2 to 2.21.3

Commits

374fbd0 [maven-release-plugin] prepare release jackson-bom-2.21.3
7059df7 Prep for 2.21.3 release
2fd60bd Merge b...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Pull request opened: #13084 CI: track generated eBPF binaries in git

This simplifies our CI by removing a special case. Specifically, 'go generate' works as expected, its output can always be checked in git, and CI can check for an empty diff when calling it post-push.

The price to pay is that we track 4 small binary objects in git. This pattern is officially recommended by upstream ebpf tooling: per https://ebpf-go.dev/guides/portable-ebpf/ :

We recommend building eBPF C code from within a container with a stable LLVM toolchain, as well as checking all ge...

vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #13086 New core type: GitCommit

Problem

The core Git API currently models branches, tags, HEAD, and commit IDs through GitRef. That works well for ref lookup and tree checkout, because a commit ID can be used as a ref-like revision.

But commit metadata does not belong directly on GitRef. A ref is a pointer or name that resolves to a commit; the commit itself is the immutable object that has author, committer, message, parent, and tree metadata.

Today this leaves no clean place to expose commit details such as comm...

vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13087 Remove stale graph handles from execution metadata

Summary

This PR fixes the missing shared result failure mode that could show up after an earlier failed module SDK/type-def generation attempt. The root cause was that execution metadata persisted encoded dagql object/call IDs such as module IDs, function calls, and other loadable graph handles. If the first attempt failed at the wrong point, a later retry could read stale execution metadata from cache and try to reload graph state that was no longer valid, producing errors like `failed...

vivid lintelBOT
#
shykes
[dagger/dagger] Pull request opened: #13088 core: add GitCommit type

Summary

  • add a new GitCommit core type with commit metadata fields and tree checkout support
  • add GitRef.asCommit and make GitRepository.commit(id:) return GitCommit for v0.21.0+ while preserving the legacy GitRef return for older schema views
  • regenerate the Go SDK and add focused parser/integration coverage

Fixes #13086

Verification

  • GOOS=linux GOARCH=amd64 go test -c ./core -o /tmp/core.test
  • GOOS=linux GOARCH=amd64 go test -c ./core/schema -o /tmp/schema.test
  • GOOS=linux GOA...
vivid lintelBOT
#
gregoryboue
[dagger/dagger] Issue opened: #13089 Python SDK: inherited @function methods from parent classes no longer registered since v0.20.7 (AST analyzer regression)

What is the issue?

Description

Since Dagger v0.20.7, @function-decorated methods inherited from parent classes are no longer visible in dagger functions output or dagger call --help. They were working correctly in v0.20.6.

Root Cause

PR #11803 ("feat(sdk/python): AST based analysis to introspect"), backported into v0.20.7, replaced the runtime-based introspection with a static AST parser.
Before (v0.20.6): The SDK used inspect.getmembers(cls) which traverses the Python ...

vivid lintelBOT
#
eunomie
[dagger/dagger] Pull request opened: #13090 fix(sdk/python): discover @function methods inherited from base classes

Summary

  • Fixes #13089. Inherited @function methods stopped showing up in dagger functions / dagger call --help when the Python SDK switched from runtime introspection to a static AST analyzer in v0.20.7 (#11803). The new analyzer iterated only over a class's own node.body and never walked base classes for @function methods, while inspect.getmembers() previously discovered them via Python's MRO.
  • The fix mirrors the existing _find_inherited_constructor pattern: a new `_find...
vivid lintelBOT
#
eunomie
[dagger/dagger] Pull request opened: #13091 fix(sdk/python): handle relative imports in AST analyzer

Summary

The AST analyzer used by dagger develop for the Python SDK didn't handle relative imports correctly:

  • from . import x raised ValueError because importlib.import_module was called with an empty module name.
  • from .x import y (and other dotted relative forms) fell through to importlib, where they either errored or silently resolved to the wrong top-level module.

This meant a Dagger module split across multiple files using ordinary Python relative imports could fail t...

vivid lintelBOT
#
eunomie
[dagger/dagger] Pull request opened: #13093 fix(sdk/python): handle module-level type aliases in AST analyzer

Summary

The AST analyzer used by dagger develop for the Python SDK silently mishandled module-level type aliases such as:

Source = Annotated[dagger.Directory, dagger.DefaultPath(".")]

@dagger.object_type
class Foo:
    @dagger.function
    def build(self, src: Source) -> dagger.Container: ...

Two things went wrong:

  • Type resolution: Source was never registered in the analyzer's namespace, so _resolve_name fell through to its catch-all path and warn-assumed `So...
vivid lintelBOT
vivid lintelBOT
#
eunomie
[dagger/dagger] Pull request opened: #13095 fix(sdk/python): close 15 AST analyzer gaps surfaced by user reports

Why

The Python SDK's static AST analyzer (introduced in #11803) replaced the
runtime typing.get_type_hints() introspection that used to back
dagger develop / dagger functions. The runtime path quietly handled
a lot of Python's surface area — aliases, MRO walks, type-alias
re-exports, optional wrappings, cross-file imports — because Python
itself does that work for you. The AST analyzer does it from scratch
against the parse tree, so each Python idiom that the analyzer doesn't
expl...

vivid lintelBOT
#
eunomie
[dagger/dagger] Issue opened: #13097 Python SDK: AST-based module analysis misses several Python patterns

What happened

In v0.20.7 (#11803) we changed how the Python SDK reads your module to register it with the engine. The old way ran your code; the new way reads it as text only. Reading text instead of running code is the right long-term move — it unlocks a feature called "self calls" — but the new reader doesn't yet recognise everything Python can express.

That means modules that worked fine in v0.20.6 may now register the wrong types or skip parts of the schema in v0.20.7 and later.

...

vivid lintelBOT
vivid lintelBOT
#
vito
[dagger/dagger] Pull request opened: #13099 fix(core): propagate service exits to dependents

Summary

  • cancel withExec calls when a bound service exits so the service failure is surfaced
  • propagate bound-service exits through container-backed services
  • suppress service-exit propagation for interactive terminals so the user's shell stays open

Tests

  • dagger call --progress=dots engine-dev test --run 'TestServices/TestServiceDependencyExitShortCircuits' --pkg ./core/integration/
  • `dagger call --progress=dots engine-dev test --run 'TestModule/TestDaggerTerminal/bound ser...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
sagikazarmark
[dagger/dagger] Issue opened: #13102 ✨ Dang SDK: Add support for with functions

What are you trying to do?

Coming from the Go SDK, I'm really used to the With function on types, because it allows using the builder pattern without breaking it up into different parts.

For example:

container.
    WithEnvVar("FOO", "BAR").
    With(cacheMounts)

I think this should already be possible to implement using blocks?

Why is this important to you?

Nicer code :)

How are you currently working around this?

I don't :(

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13108 Fix nested client session race

Fix nested client session resolution

Main goal here is to fix a regression introduced by fix: builtin dang dependency module loading (#13007).

  • It resulted in occasional errors like Error: failed to load module source dependencies: loading workspace: workspace detection: failed to stat path: failed to get requester session: session for "v51anobcgxoitkmvey93jzs6z" not found

The first commit is the direct fix: it separates exact clie...

vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13109 fix user defaults parallel test race

Hit a failed run in CI due to race detector going off during test: https://dagger.cloud/dagger/checks/github.com/dagger/dagger@a1fb6be1af1460b4470021e69ba126463cd0fcb6?check=test-split:test-base&span=59440d44c1f434db&viewMode=trace

TestUserDefaults/TestSimple runs table cases under the integration suite's parallel middleware. The test built one shared base container in the outer function scope and then one table case reassigned that shared variable from inside its parallel subtest when app...

vivid lintelBOT
vivid lintelBOT
#
eunomie
[dagger/dagger] Pull request opened: #13111 Go SDK: replace packages.Load type discovery with AST scan

Summary

Replaces the Go SDK's packages.Load-based source analysis with a pure AST scan and folds type discovery into the same generate-module codegen call that produces the bindings. The standalone generate-typedefs codegen path and the Go SDK's moduleTypes engine entrypoint are both removed.

What changes

  • New cmd/codegen/generator/go/astscan package — go/parser + go/ast walker that extracts a module's declared types and resolves references against the introspection sc...
ornate vigilBOT
vivid lintelBOT
#
suprjinx
[dagger/dagger] Issue opened: #13112 🐞 Parallel `dagger check` no longer caching identical `withExec`

What is the issue?

We're seeing some layer-cache misses where we'd expect hits since the buildkit removal. Two parallel checks resolving to an identical withExec() chain each run the the underlying exec. Pre PR-#11856, the same chain was deduped and only ran one exec.

Dagger version

dagger v0.20.6 (but running hack/dev from main)

Steps to reproduce

# src/dedupe/main.py
import dagger
from dagger import dag, check, function, object_type

CACHE_KEY = "dedupe_probe"
...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
immanuwell
[dagger/dagger] Pull request opened: #13116 fix: allow configuring Helm StatefulSet replicas

Closes #13066.

Tiny fix, but useful imo: StatefulSet.spec.replicas was hardcoded to 1, so the chart could not scale StatefulSet engines even when users passed a replicas value.

Repro before this patch:

helm template repro helm/dagger \
  --set engine.kind=StatefulSet \
  --set engine.statefulSet.replicas=3

Expected spec.replicas: 3, got spec.replicas: 1 because the template had the value baked in.

This adds engine.statefulSet.replicas with the same default of 1, so ...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13118 dagql: dedupe session calls across clients

Use the session ID as the default DagQL concurrency key so equivalent in-flight calls can be single-flighted across clients in the same session.

Add same-session fallback for secret and socket session resources when the original client attachable is no longer available. This intentionally does not cover host services or mid-stream SSH forwarding retry.

Fix for https://github.com/dagger/dagger/issues/13112, but requires some more validation; deduping inflight requests is good but ...

vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13119 Use recipe IDs for module type generation

Background

Module type generation currently has SDKs construct a container that writes a module ID to a file, then the server reads that ID back. That path is being reworked separately, but the current implementation is flaky: the written ID can be handle-based, and if that handle goes stale before the dependency wiring catches up, module type generation can fail intermittently.

This change is a narrower fix for that race while the larger module types rework is still in progress.

Cha...

vivid lintelBOT
#
paulvinueza30
[dagger/dagger] Pull request opened: #13120 fix(go-sdk): re-enable TestConnectOption

Summary

  • Re-enable TestConnectOption in the Go SDK test suite
  • Replace io.Pipe log capture with a thread-safe buffer because io.Pipe was hanging at Connect
  • Update the assertions to match the current connection and log output more reliably

What I changed

This updates sdk/go/client_test.go to make TestConnectOption work again.

The previous version of the test was skipped because it was broken and producing empty output. In practice, the io.Pipe approach was hanging at ...

vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13121 core: disable git auto maintenance for changesets

Summary

  • Disable Git auto-maintenance and auto-gc for ephemeral changeset merge repositories.
  • Add context to temporary .git cleanup errors in the changeset merge paths.
  • Rename engine snapshotter temp mount directories from buildkit-mount to dagger-mount.

Why

CI has seen flaky unlinkat failures while removing the temporary .git directory used during generated changeset checks. This is still a hypothesis rather than a proven root cause, but the current evidence points at...

vivid lintelBOT
vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13122 Parallelize Go runtime generation

Summary

dagger check dagger-dev:generated spends a lot of time in go:generate-dagger-runtimes, but the Go runtime generation work was being forced serially across modules.

This changes GenerateDaggerRuntimes to generate per-module runtime layers in parallel, using the existing Go toolchain limit setting. The default limit is bumped to 10, and generated layers are applied back in module order so the final changeset remains deterministic.

The generated Go bindings were updated for...

vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13123 [codex] lazy operation leases

Summary

  • Replace eager per-operation containerd lease creation with a lazy operation lease scope.
  • Ensure the lazy lease at snapshot/content boundaries that actually need containerd lease membership, with existing explicit fallback leases still available outside DAGQL operation scopes.
  • Add focused coverage for lazy lease behavior, DAGQL lease acquisition, and snapshot manager create boundaries.

Root Cause

The e-graph-era operation lease provider eagerly called leaseutil.WithLease b...

#
sipsma
[dagger/dagger] Pull request opened: #13124 [codex] flatten chained withDirectory evaluation

Summary

  • Flatten lazy Directory.withDirectory chains so evaluating the final directory only materializes the base and each source once, then applies the chain in a single pass.
  • Reuse that directory chain replay for Container.withDirectory chains, including mounted directory targets, while conservatively falling back for named owner resolution that requires parent filesystem lookup.
  • Add integration coverage for layered chained directory/container semantics, mounted container direc...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #13128 chore: bump the sdk-elixir group in /sdk/elixir with 2 updates

Bumps the sdk-elixir group in /sdk/elixir with 2 updates: ex_doc and jason.

Updates ex_doc from 0.40.1 to 0.40.2

Changelog
Sourced from ex_doc's changelog.

v0.40.2 (2026-05-08)

Bug fixes

Add rel="nofollow" to external links in HTML output
Use blockquote in llms.txt description
Void elements in epub, such wbr, must be terminated by the matching end-tag
Fix content container scrolling in older ve...

vivid lintelBOT
#
eunomie
[dagger/dagger] Pull request opened: #13130 cli: add experimental `dagger module-checks` command

Summary

  • Adds dagger module-checks @ — an experimental Cloud-discovery subcommand that fetches the recorded checks for a given commit and renders a colored progress bar + grouped per-check table.
  • Two flags for non-interactive consumers:
    • --json emits a stable JSON document (matched commit, refs, summary counts, per-check status/duration/traceId/traceUrl).
    • --watch refetches and redraws every 5 seconds until interrupted; works for both human and JSON output.
  • Factors a reus...
vivid lintelBOT
ornate vigilBOT
#
TomChv
[dagger/dagger] New comment on discussion #13055: Dagger develop running `go mod tidy`

Thanks both! Just wanted to also point out that my initial speculation for go mod tidy causing dependencies to be upgraded was incorrect, it's actually a go get -u that runs within the Dagger develop that is causing those. Is there any intention in keeping this behaviour when running develop?

We might be able to get the dagger package without dynamically add it to the module's code if we don't codegen at runtime because we would assume the go.mod of that module is right.
We could just a...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13132 test: fix helm check filtered workspace

What changed

This fixes the Helm e2e package under the filtered golang:check workspace.

  • Include e2e/helm/dagger.json in the Helm test workspace inputs so the runtime module config matches the generated Go client.
  • Harden version.New so it only stores a Git repository when the provided .git directory can actually resolve HEAD; otherwise it uses the existing fallback version path.

Why

TestInstallK3S mounts dag.DaggerCli().Binary() into the Helm/kubectl container. The ...

vivid lintelBOT
#
beingminimal
[dagger/dagger] Pull request opened: #13133 Incus support added as container runtime

This PR adds first-class Incus runtime support to Dagger and hardens the image loading/extraction path so it correctly handles modern Linux rootfs layouts.

The user-facing runtime name is now consistently Incus, not LXC. The implementation aligns with the incus CLI/daemon and image+incus://... engine config format, which matches how users actually install and operate the runtime.

This PR also improves the Incus image conversion path to be safer and more compatible with real-worl...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
exe-dev-github-integration[bot]
[dagger/dagger] Pull request opened: #13135 Add built-in module sources

Problem

Runtime modules are still handled like normal module sources. That makes engine-bundled SDK runtimes harder to expose, list, and cache as first-class sources.

Solution

Add a built-in module catalog and a BUILTIN_SOURCE module kind. Add GraphQL fields to resolve one built-in source or list the catalog. Load bundled runtimes from their embedded rootfs when a manifest digest is available. Keep git-backed fallbacks for other runtimes. Regenerate SDKs and API docs.

#
shykes
[dagger/dagger] Pull request opened: #13136 Add built-in module sources

Problem

SDK runtime modules need stable names. Today, callers must know where each runtime module lives. That makes module references harder to use and harder to move.

Solution

Add built-in module sources backed by an engine catalog. Dagger can now resolve names like python-runtime and typescript-runtime through the GraphQL API. The change also exposes catalog listing, persists built-in source metadata, resolves built-in dependencies, and regenerates SDK and API references.

vivid lintelBOT
#
chasecaleb
[dagger/dagger] Pull request opened: #13137 Add NixOS-style support to custom CA cert installer

NixOS and Nix-built distroless images expose the system CA bundle as a symlink into a read-only /nix/store target, so commonInstaller's append path can't write through it. Add a nixosLike installer that detects NixOS via /etc/NIXOS or ID=nixos/ID_LIKE=nixos, locates the bundle via $SSL_CERT_FILE (falling back to /etc/ssl/certs/ca-certificates.crt), materializes the symlink as a writable regular file for the duration of the exec, and restores the symlink on uninstall.

Also adds a small Cont...

vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13138 test: reproduce inline dependency contextual dir cache bug

Problem

@tiborvass reported a false-positive cache hit around inline module dependencies and contextual directory defaults. The important shape is: module A calls module B, B loads a host directory through an annotated/defaultPath argument, A returns a value derived from B, and a later session can reuse the cached result for A after the contextual directory used by B changed.

Reproduction

This adds TestCrossSessionInlineDependencyContextualDirChange, a focused Go-only cross-session...

vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #13139 Directory.asModuleSource fails resolving local deps from module context

Summary

When Directory.asModuleSource is called from inside a Dagger module, resolving a local module dependency can fail while loading user defaults.

It looks like DIR_SOURCE user-default loading calls Host.findUp(".env") with the module client context instead of the original caller/workspace context, so host cwd/session lookup times out.

Repro

type DirModsourceRepro {
  pub direct(ws: Workspace!): ModuleSource! {
    ws
      .directory("/", include: ["main/**", "dep...
vivid lintelBOT
vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13141 Fix remote git tree reuse after prune

Summary

  • Add an integration repro for a remote git tree failing after explicit local cache prune.
  • Remove the separate git-snapshot metadata fast path from core RemoteGitRef.Tree.
  • Rely on the persistable dagql GitRef.tree result as the persistent cache authority for remote git trees.

Details

@vito found and reported a failure where a remote git tree could be fetched successfully, pruned, and then fail on the next fetch with a raw snapshot key not found error.

The repro s...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
paulvinueza30
[dagger/dagger] Pull request opened: #13143 fix: allow uninstalling stale local toolchains

Summary

  • Fixes #13059.
  • Allow local toolchains to be uninstalled after their source path is deleted.
  • Preserve other toolchain resolution errors.
  • Add integration coverage for toolchain uninstall behavior.

Testing

  • dagger call engine-dev tests
  • Specific test added for this fix: dagger call -m ./toolchains/engine-dev test --pkg=./core/integration --run='TestToolchain/TestToolchainUninstall' --test-verbose -d
  • dag checks 'go:lint'
vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13144 Reuse pooled CNI namespaces for default execs

Summary

  • route ordinary execs with the default dagger hostname through the existing CNI namespace pool
  • keep explicit hostnames and insecure execs on the fresh namespace path
  • fix --oci-cni-config-path so it reads the correct flag value
  • remove the stale inherited BuildKit bridge-provider mode, including networkMode=bridge, BUILDKIT_NETWORK_BRIDGE_AUTO, and the unused bridge config fields

Details

Dagger already configures a CNI namespace pool, but normal execs were not us...

vivid lintelBOT
#
paulvinueza30
[dagger/dagger] Issue opened: #13145 Show trace URL when browser open fails on headless machines

Problem

When running Dagger on a headless Linux machine, such as a VPS over SSH, `dagger` may try to open a Dagger Cloud trace URL with `xdg-open`.

If no browser is available, this currently warns with output like:

```text
04:59:45 WRN failed to open URL url=https://dagger.cloud/paulvinueza30/traces/40467b9c069ba80a7977f6c45ae36c73#58fe4c21d79fc856 err="exit status 3" output="/usr/bin/xdg-open: line 881: www-browser: command not found\n/usr/bin/xdg-open: line 881: links2: command...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
marcosnils
[dagger/dagger] Issue opened: #13147 🐞 Regression: WithSecretVariable doesn't override previously set values

What is the issue?

Reported by @danielgafni here: #typesafe message

According to him, this did not happen in v0.20.7.

Dagger version

v0.20.8

Steps to reproduce

@function
async def test_secret_override(self) -> str:
    """Reproduce with_secret_variable override regression in Dagger 0.20.8."""
    short = dag.set_secret("short", "AA")
    long = dag.set_secret("long", "BBBBBBBBB")
 ...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
marcosnils
[dagger/dagger] Pull request opened: #13149 fix(sdk/python): expand TypeAlias inside union annotations (X | None)

_expand_alias only walked bare ast.Name nodes via a while loop, so compound annotations like Name | None passed through with the alias unexpanded. The resolver then saw "Name" as an unknown type and assumed it was an object, which the engine rejected with "find mod type for function … arg … type: "Name"".

After the top-level name-expansion loop, recurse into ast.BinOp BitOr nodes and expand aliases in both operands. An identity check ensures a new node is only allocated when something ...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13151 [codex] Improve Java codegen query errors

What

Make the Java codegen Maven plugin preserve and report failures from dagger query -s -M instead of suppressing stderr and handing empty stdout to schema parsing.

Why

The current Java SDK CI failure is a NullPointerException that masks the real nested Dagger query error. This diagnostic change should let CI show the underlying query stderr/stdout and exit status.

Validation

  • dagger -m toolchains/java-sdk-dev call lint --progress=plain
  • `dagger -m toolchains/java-sdk-...
#
shykes
[dagger/dagger] Issue opened: #13152 ModuleSource.withDependencies rejects directory-backed module sources

Summary

ModuleSource.withDependencies fails when the target module source is created with Directory.asModuleSource.

This is not specific to module execution. It reproduces from a normal Dagger client. A nested helper does not avoid the bug if it constructs module sources with Directory.asModuleSource, because the resulting source kind is DIR_SOURCE.

Repro

Requirements: Go and the Dagger CLI.

tmp="$(mktemp -d)"
cd "$tmp"

mkdir -p app lib

cat > app/dagger.json < app/m...
vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13153 trace: honor frontend flags in replay

Problem

dagger trace replayed recorded progress through the frontend, but it constructed fresh frontend options instead of using the global CLI options. That meant replay ignored verbosity and debug flags such as -v, -vvvv, and --debug.

Fix

Copy the global frontend options for trace replay and override only NoExit, preserving the existing behavior of keeping the trace UI open.

Test

  • `dagger --progress=plain call engine-dev test --pkg ./cmd/dagger --run TestTraceUsesGl...
vivid lintelBOT
vivid lintelBOT
#
incendium
[dagger/dagger] Issue opened: #13154 🐞 dag.GitRepository() is does not work with Git LFS repos

What is the issue?

As discussed with @marcosnils, I am opening this issue. Here's my original message in #help on the Discord:

Is there native Dagger support for checking out repos using Git LFS with dag.git() and having it do the full pull operation? I noticed one of my builds was failing, and when I peeked inside the container, it appears that some of the files stored in Git LFS had Git metadata in place of the actual file contents. I see some hits on this Discord about how to po...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
tiborvass
[dagger/dagger] Pull request opened: #13156 cli: allow testing unreleased builds with --x-release

Add an experimental CLI selection path for testing Dagger builds from a github.com/dagger/dagger git ref.

Users can pass either --x-release= or DAGGER_X_RELEASE= to run a specific unreleased CLI build. Flags take precedence over the environment when both are present. If the ref is not already a full commit SHA, the CLI resolves it through GitHub, prints the resolved SHA, and tells the user how to pin that exact build for repeatable testing.

The selected CLI is downloaded and re-exec...

vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #13157 Workspace.moduleSource(): load a module from a workspace

Problem

A module can receive a Workspace, but it cannot load another Dagger module from that workspace.

For example, a module should be able to say: "load the module at ./foo in this workspace" and get back a ModuleSource.

Today there is no direct core API for that. The only option is to implement a module-side shim for Workspace.moduleSource().

That shim is difficult and unreliable for several reasons:

  1. Low-level module loading logic must be reimplemented: walking dependenc...
#
shykes
[dagger/dagger] Issue opened: #13158 TUI: Show meaningful progress for container image pulls

Problem

When the engine pulls a container image, the TUI shows a stream of raw HTTP GET log lines. From a user on Discord:

This is still very confusing. Is it pulling an image? Is Docker having issues? Even a simple progress bar to tell me that it's trying to pull an image would be helpful.

Solution

Replace the raw log output with a proper progress display. From @vito on Discord:

We used to have a slick 2-dimensional progress bar in the TUI (X axis = layers, Y axis = per-laye...

vivid lintelBOT
vivid lintelBOT
#
grouville
[dagger/dagger] Pull request opened: #13162 fix(sdk/python): make static annotation analysis alias-aware

Summary

This PR tightens the Python SDK module analyzer around type annotations, especially type aliases, quoted annotations, and Annotated[...] metadata.

The analyzer runs during the Python SDK module-types registration path. When the engine asks the SDK runtime for a module's type definitions, the runtime discovers the module's Python source files and analyzes them without importing the user module. The analyzer produces internal ModuleMetadata, which the SDK converts into Dag...

vivid lintelBOT
vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13163 Handle empty plaintext secret handles

Summary

  • derive provider-secret handles for zero-length plaintext instead of treating them as missing
  • add an integration repro for an empty env-backed Secret used through constructor user defaults

Root Cause

Provider-backed secrets without an explicit cache key derive their session resource handle from plaintext. Empty plaintext previously returned an empty handle, so user defaults like password=env://PASSWORD failed during object decoding when PASSWORD was set to an empty str...

vivid lintelBOT
vivid lintelBOT
ornate vigilBOT
#
guettli
[dagger] New discussion #13164: How to debug unexpected cache-misses between consecutive `dagger call` runs?

I am trying to optimize my local development workflow and ensure that running a dagger call for the second time hits the cache completely (no code changes have occurred).

However, I am currently experiencing unexpected cache-misses on the second run, and certain steps are executing all over again.

I want to inspect exactly why Dagger/BuildKit is invalidating the cache for these specific steps.

  • How can I see which input data, arguments, environment variables, or directory snapsh...
#
marcosnils
[dagger/dagger] New comment on discussion #13164: How to debug unexpected cache-misses between consecutive `dagger call` runs?

cache invalidation could happen because of several things like actual invalidatoins because of inputs changing, garbage collection, non-deterministic steps and of course Dagger bugs.

Is there any chance you can provide here a snippet that reproduces consistently what you're seeing? This would be the fastest way for us to provide feedback.

On top of that, if you have a https://dagger.cloud (free for single users) trace we could take a look at, that's also super useful.

vivid lintelBOT
#
guettli
[dagger/dagger] Pull request opened: #13165 feat: add --fail-on-cache-miss flag to dagger command

Overview

This PR introduces a new --fail-on-cache-miss flag for the dagger command that allows users to enforce cache-only execution mode.

Motivation for the --fail-on-cache-miss Argument

The --fail-on-cache-miss flag serves several important purposes:

  1. Cache Validation and Testing: During development and CI/CD pipelines, developers need to verify that their builds are being properly cached and served from cache. This flag enables strict cache validation by failing the ex...
ornate vigilBOT
#
guettli
[dagger/dagger] New comment on discussion #13164: How to debug unexpected cache-misses between consecutive `dagger call` runs?

I am not in a hurry. First I want to solve the issue in general before I dive into solving the particular cache-miss.

With the help of some smart tool, I create a PR which adds a new flag: --fail-on-cache-miss. My goal is to execute dagger call always twice. The second time with --fail-on-cache-miss. For my use case the overhead of the second call is fine, as long as it terminates immediatly when the second call terminate on cache-miss.

PR:

[feat: add --fail-on-cache-miss fla...

#
marcosnils
[dagger/dagger] New comment on discussion #13164: How to debug unexpected cache-misses between consecutive `dagger call` runs?

Thx for taking the time to send a PR for this. Getting something like this merged is a bit more complex than just looking at the call spans from the telemetry. Dagger has different caching layers and sometimes even when a specific step is cached, it might not appear as so in the telemetry because of different reasons

We're constantly improving this so caching is more robust and observability more consistent. As mentioned above, my advise to proceed here would be to share some traces from...

ornate vigilBOT
#
guettli
[dagger/dagger] New comment on discussion #13164: How to debug unexpected cache-misses between consecutive `dagger call` runs?

Thx for taking the time to send a PR for this. Getting something like this merged is a bit more complex than just looking at the call spans from the telemetry. Dagger has different caching layers and sometimes even when a specific step is cached, it might not appear as so in the telemetry because of different reasons

We're constantly improving this so caching is more robust and observability more consistent. As mentioned above, my advise to proceed here would be to share some traces ...

vivid lintelBOT
#
iahsanGill
[dagger/dagger] Pull request opened: #13166 chore(deps): bump opentelemetry log packages from v0.17.0 to v0.19.0

Closes #13040

Summary

Bumps the four replace directives (and matching require lines) in both go.mod and sdk/go/go.mod for the OpenTelemetry log packages from v0.16.0/v0.17.0 to v0.19.0:

  • go.opentelemetry.io/otel/log
  • go.opentelemetry.io/otel/sdk/log
  • go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp
  • go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc

Why

  1. CVE-2026-39882 ([GHSA-w8rr-5gcm-pp58](https://github.com/advisories/GHSA-w8rr-5gcm...
ornate vigilBOT
vivid lintelBOT
ornate vigilBOT
#
guettli
[dagger/dagger] New comment on discussion #13164: How to debug unexpected cache-misses between consecutive `dagger call` runs?

Thx for taking the time to send a PR for this. Getting something like this merged is a bit more complex than just looking at the call spans from the telemetry. Dagger has different caching layers and sometimes even when a specific step is cached, it might not appear as so in the telemetry because of different reasons

Is that an issue of Dagger or buildKit LLB, that --fail-on-cache-miss can't be easily implemented?

vivid lintelBOT
vivid lintelBOT
#
gtzo-anchorage
[dagger/dagger] Issue opened: #13169 🐞 WithServiceBinding + WithExec fails: dnsmasq addnhosts has IP entries with empty hostnames

What is the issue?

When a consumer container has any WithServiceBinding(alias, svc) and is then evaluated with WithExec(...).Stdout(ctx) (or .Sync(ctx)), the exec fails immediately at host-alias setup time with:

lookup  for hosts file: lookup  on 10.87.0.1:53: no such host
lookup ..dagger.local on 10.87.0.1:53: no such host

This happens before the consumer's command runs at all — the consumer's command can be a harmless echo, never referencing the bound alias, and i...

#
danielwegener
[dagger/dagger] Issue opened: #13170 [bug] TypeScript SDK: optional `boolean` parameters/fields fail module introspection

Disclaimer: SORRY THIS IS AI SLOPPED. I however think, the analysis makes sense and the suggested fix is reasonable.

Summary

In the TypeScript SDK, marking a primitive boolean argument or class field as optional (either with ? or with a default value) breaks module introspection. The introspector tries to resolve "boolean | undefined" as a type reference and fails:

IntrospectionError: could not resolve type reference for boolean | undefined.
    at DaggerModule.resolveReferenc...
vivid lintelBOT
ornate vigilBOT
vivid lintelBOT
#
eunomie
[dagger/dagger] Pull request opened: #13171 fix(sdk/python): resolve absolute self-imports in AST analyzer

What this fixes

The Python SDK's static module analyzer derives a module's API from its source code, without importing it. When a module is split across files, it only followed relative imports (from .params import Foo) to find names defined in sibling files.

Modules that import their own siblings absolutely (from my_pkg.params import Foo) — a common style — left those names unresolved. A type alias imported that way collapsed to an unresolved custom type instead of its real ...

vivid lintelBOT
vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13172 Lock TypeScript SDK yarn cache

Summary

Lock the TypeScript SDK Yarn cache volume so concurrent lint checks do not mutate Yarn v1 global cache at the same time.

Root Cause

ci:bootstrap can run typescript-sdk:lint-typescript and typescript-sdk:lint-docs-snippets concurrently. Both construct the same Node dev container and run yarn --cwd sdk/typescript install against the same Yarn cache volume. With the default SHARED cache mode, those installs can overlap and leave partial Yarn v1 cache entries, producing...

#
sipsma
[dagger/dagger] Pull request opened: #13173 Testing only: capture Namespace cache persistence shutdown errors

Testing only

This draft PR intentionally makes a tiny docs-only change so we can trigger CI and reproduce/cache-capture an intermittent Namespace outer-engine shutdown issue.

We are specifically investigating errors while the Namespace-backed outer engine writes the dagql cache persistence snapshot to disk during engine shutdown. The expected signal is in the outer engine logs near shutdown, around dagql cache close / persistence / clean-shutdown metadata handling.

This is not intended ...

#
lemkuralic
[dagger/dagger] Issue opened: #13174 sdk/java: mvn versions:set fails with Maven Central 429 due to unnecessary dependency resolution

The Java SDK runtime's moduleRuntime function runs mvn versions:set against the SDK parent POM. This command only modifies version strings in the POM XML, but Maven still resolves the full dependency tree (including BOM imports like jackson-bom and junit-bom and others from Maven Central).

The problem is that Maven Central started rate limiting (HTTP 429) and as a result, module loading has become flaky, sometimes completely failing. This seems to have been more common (complete failures o...

vivid lintelBOT
vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #13175 chore: bump protobufjs from 7.5.4 to 7.6.0 in /docs

Bumps protobufjs from 7.5.4 to 7.6.0.

Release notes
Sourced from protobufjs's releases.

protobufjs: v7.6.0
7.6.0 (2026-05-18)
Features

Support BigInt conversions (7.x) (#2258) (f769242)

protobufjs: v7.5.9
7.5.9 (2026-05-17)
Bug Fixes

Backport bundler-safe optional module lookups (#2254) (0853a62)

protobufjs: v7.5.8
7.5.8 (2026-05-12)
Bug Fixes

Backport parser hardening to 7.x (#2245) (54b593f)

protobufjs: v7.5.7
7.5.7 (2026-05-09)
Bug Fixes...

vivid lintelBOT
#
tiborvass
[dagger/dagger] Pull request opened: #13177 Scrub plaintext Secret user defaults

Treat schemeless .env values for Secret user defaults as plaintext secrets instead of address-style secret provider URIs.

This routes those values through setSecret so they resolve as Dagger Secrets without exposing the raw value in the user default console output. URI-style values such as env:// and op:// keep the existing provider behavior.

Adds regression coverage for a plaintext Secret default to ensure the displayed default is scrubbed while the secret still resolves correctly.

vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13178 core: persist container withNewFile lazy hits

What changed

This fixes persisted container lazy hit reloads for Container.withNewFile.

withNewFile builds a File and stores the container using the same ContainerWithFileLazy persisted payload shape as withFile, but the persisted lazy decoder only accepted the withFile GraphQL field. After an engine restart, loading an unevaluated persisted withNewFile hit failed with unsupported field "withNewFile".

The decoder now accepts both withFile and withNewFile for that pay...

vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13180 core: restore persisted cache volume mount sharing

Summary

This PR adds a focused integration repro for a persisted source-backed cache volume mount failure, then fixes the persisted cache volume decode path.

After a persisted engine restart, CacheVolume reopened its mutable snapshot by snapshot ID without restoring the exec.cachemount record type that fresh cache-volume initialization sets. That record type is required for mutable cache mounts to use the existing shareable mount wrapper. Without it, concurrent execs mounting the sam...

#
sipsma
[dagger/dagger] Pull request opened: #13181 ci: investigate intermittent disk full failures

Summary

Draft PR for CI-only testing. The diff is intentionally inert; it exists only to trigger CI so we can investigate intermittent disk-full failures on Namespace-backed outer engines.

The suspected failure mode is not caused by this README marker. We are trying to observe jobs where the outer engine restarts from previously used disk state, then collect failing traces, Namespace instance details, outer-engine logs, pruning logs, and engine metrics around disk usage.

Validation

...

vivid lintelBOT
ornate vigilBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
suprjinx
[dagger/dagger] Issue opened: #13183 🐞 Plaintext secrets are leaking to TUI since PR 11856

What is the issue?

We're seeing secrets print to the TUI console (withMountedSecret step) since 0.20.8 on main. This seems to be related to dagql caching introduced in PR #11856.

Eg,

9   : ReproCacheIssueDagger.test: String!
10  : ┆ Container.from(address: "alpine:latest"): Container!
10  : ┆ Container.from DONE [0.1s]
11  : ┆ Container.withMountedSecret(
11  : ┆ ┆ path: "/123"
11  : ┆ ┆ source: setSecret(name: "toast", plaintext: "<>"): Secret!
11  : ┆ ): Container!
11  : ┆ Contain...
vivid lintelBOT
#
vito
[dagger/dagger] Pull request opened: #13184 fix(dang): support core type shadowing

Summary

  • use Dang binding origins to distinguish local types from imported Dagger core types
  • avoid exporting imported bindings as Dang module definitions
  • add integration coverage for local Container/Directory shadowing and explicit Dagger.Container
  • bump Dang to the version containing the language-side shadowing fixes

Tests

  • dagger call --progress=dots engine-dev test --pkg ./core/sdk/
  • `dagger call --progress=dots engine-dev test --run 'TestDang/TestCoreTypeShadowing...
vivid lintelBOT
#
suprjinx
[dagger/dagger] Pull request opened: #13185 dagql: redact sensitive args in ResultCall telemetry protobuf

ResultCall.callPB / resultCallArgPB encodes the call protobuf used for the
DagCall telemetry span attribute (core/telemetry.go). It emitted arg values
verbatim and ignored ResultCallArg.IsSensitive, so sensitive arguments such
as setSecret(plaintext:) were sent to telemetry and rendered unredacted in
the CLI --progress output (e.g. as the embedded source: of withMountedSecret).

This regressed in #11856 ("migrate all caching to dagql"): the old call.ID
path redacts sensitive args via r...

vivid lintelBOT
#
tiborvass
[dagger/dagger] Pull request opened: #13186 test: make fail-multi telemetry ordering deterministic

Rewrite the fail-multi viztest helper so the two failing child spans are created, executed, and ended sequentially instead of through nested function arguments passed to errors.Join.

The test is meant to verify how multiple failed child spans are rendered, not to depend on evaluation or span-end ordering. Making the two failing effects explicitly ordered keeps the golden output stable while preserving the same joined-error behavior.

vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13187 core: harden integration test scalar output parsing

Summary

  • harden TestEnvFile/TestSecretFile output parsing so combined stderr diagnostics cannot be decoded as scalar output
  • add a stdout-only host Dagger helper and use it for socket ID scalar output passed between calls

Details

The flaky env-file test captured combined CLI output and decoded the last raw line as base64. The CLI can still emit user-default diagnostics to stderr despite -s, and combined stdout/stderr can leave those diagnostics after a trailing newline or interle...

vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13188 core: pin Vault image in TTL secret provider test

Summary

  • pin TestSecretProvider/TestVaultTTL to hashicorp/vault:1.18
  • reuse that pinned image for the Vault service, copied CLI binary, and nested module Vault clients

Details

TestSecretProvider/TestVaultTTL was pulling the untagged hashicorp/vault image in several places. That tag now resolves to Vault 2.0.1, created on 2026-05-19. In this environment, the new image fails before any Dagger-specific secret-provider behavior is exercised:

sh: vault: Operation not perm...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
eunomie
[dagger/dagger] Pull request opened: #13190 core: remove scale-out path for dagger generate

Summary

  • The generator scale-out path returned a Changeset whose Directory fields reference objects that only exist on the remote engine, so the local engine cannot materialize the generated files — it could never work in practice.
  • Drop tryRunGeneratorScaleOut and the scale-out branch in RunGenerator; dagger generate always runs locally.
  • Scale-out is preserved for dagger check and the generate-as-check flow, where only a boolean/error result crosses engines.

Test plan...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13191 [codex] test reproducing unknown command error in CI

This draft PR exists to reproduce the intermittent unknown command failure in TestModule/TestFunctionCacheControl under CI.

It intentionally contains no tree changes; the branch has an empty signed-off commit so the normal CI checks run against the current code.

Plan:

  • Watch test-split:test-modules for this PR.
  • Rerun that Dagger Cloud check up to 30 times.
  • Stop if a failure contains the unexpected unknown command signature.
#
sipsma
[dagger/dagger] Pull request opened: #13192 Testing reused cache mounts in CI

Summary

This is a no-diff draft PR for validating reused cache mounts in CI.

The branch contains only an empty commit so it can produce PR CI runs. After creation, this PR number can be shared so the CI info feature can be selectively enabled for this PR, letting us observe and debug whether cache mounts on CI runners are reused across runs.

Testing

Not run locally; this PR is intended to exercise CI.

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dagger-codex[bot]
[dagger/dagger] Pull request opened: #13195 test: cover compat install migration guard

Summary

  • treat SDK-only dagger.json as legacy compat state for install mutation tests
  • document compat detection expectations for SDK-only root and child configs
  • extend migration coverage so SDK-only config is migrated before install mutates workspace config

Tests

  • go test ./core/integration -run '^$'
  • `dagger --progress=logs call engine-dev test --pkg=./core/integration --run='^TestWorkspaceModules/TestWorkspaceModuleInstall/install_initializes_empty_workspace$|^TestWorkspac...
vivid lintelBOT
#
grouville
[dagger/dagger] Pull request opened: #13196 test(sdk/python): avoid shadowing type names in property fixtures

The Python SDK property-based differential test generated a module where a Dagger field was named bool:

    @dagger.object_type
    class Foo:
        bool: str = dagger.field(default="")

        @dagger.function
        def a(self) -> bool:
            ...

That source is legal Python syntax, but it is outside the supported Dagger schema grammar.

That source is outside the supported Dagger grammar: generated Dagger members should not shadow the finite set of ...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dagger-codex[bot]
[dagger/dagger] Pull request opened: #13200 docs: update workspace beta docs

Summary

  • fix workspace docs terminology around module settings and Cloud Checks
  • expand migration, first-run recovery, CI install, security, configuration, and module author guidance
  • pin script install examples and remove stale workspace-era command references

Validation

  • dagger check -l
  • dagger check markdown-lint:lint docs:references python-sdk:lint-docs-snippets typescript-sdk:lint-docs-snippets

The selected docs checks exited 0. Trace: https://dagger.cloud/dagger/traces/...

#
sipsma
[dagger/dagger] Pull request opened: #13201 core: persist value object list results

Summary

  • Persist SearchResult, SearchSubmatch, and DiffStat values so cache-persisted list results round-trip after engine restart.
  • Reject object-like values without explicit persisted-object encoding instead of silently storing them as scalar_json.
  • Add dagql codec tests and disk-persistence integration coverage for Directory.search, search submatches, and Changeset.diffStats.

Validation

  • `dagger --progress=plain call go test --pkgs ./dagql --run 'TestPersistedSelfC...
vivid lintelBOT
#
vito
[dagger/dagger] Pull request opened: #13202 fix(dagql): end lazy resume span before unblocking waiters

:robot:

The deferred EndWithCause for the lazy-evaluation resume span fired only when the goroutine returned, which was after close(waitCh). Callers awaiting Evaluate could observe completion, flush, and read exported spans before the span was ended, racing the deferred End. Wrap the eval body in an inner function so the defer fires on its return, before close(waitCh). This also ensures the resume span is ended on the operation-lease error path, where it was previously created but never en...

#
sipsma
[dagger/dagger] Pull request opened: #13203 core: account lazy imported snapshot usage

Summary

Restarted engines can import persisted dagql object results lazily because object payload decode needs a dagql server context. Before this change, those lazy imported results retained snapshot-owner links and leases, but local-cache usage accounting ignored them until a later cache hit materialized the object value.

This makes lazy imported snapshot-owner links participate in local-cache usage and max-used prune before payload decode. The snapshot manager now exposes direct snaps...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
ornate vigilBOT
vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13206 tests: use cache accounting for stopped service prune

Summary

This is a test-only change for TestLocalCachePruneReclaimsStoppedServiceSnapshots.

The underlying engine behavior is fine: stopped service snapshots are being pruned. The previous assertion measured global filesystem free space with df, which is inherently noisy under parallel integration tests and could hide the local cache reclaim signal.

This updates the test to run against an isolated nested dev engine and assert via Engine().LocalCache().EntrySet().DiskSpaceBytes(ctx)...

vivid lintelBOT
vivid lintelBOT
#
sipsma
[dagger/dagger] Pull request opened: #13207 core: improve cache pruning and engine test splits

Summary

This PR collects a few related cache pruning and disk-pressure improvements for the engine and the engine-heavy integration checks.

Commits

  • core: use available disk space for min-free pruning
    • Fixes the min-free-space pruning decision to use filesystem available bytes instead of raw free bytes, so reserved blocks do not make the engine overestimate space users can actually consume.
    • Updates the cache and server GC plumbing/tests to carry available space through the ...
vivid lintelBOT
vivid lintelBOT
#
dagger-codex[bot]
[dagger/dagger] Issue opened: #13208 Add an option for withDirectory/with_directory to use the container's default owner

What are you trying to do?

A user building a Python Dagger module creates a non-root user in a container, for example python with uid/gid 1234, and wants every directory mounted into that container to be owned by that user. Today each call has to pass the owner explicitly:

container.with_directory(path, source, owner="1234:1234")

When this logic is shared across modules, callers either need to plumb uid/gid through their own APIs, which adds boilerplate, or resolve ui...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
eunomie
[dagger/dagger] Pull request opened: #13210 Go SDK: no-codegen-at-runtime + single-pass codegen

Draft for discussion. Stacked on the workspace branch.

What this does

Reworks the Go SDK codegen path so that:

  1. A module can opt out of codegen at runtime. With
    codegen.legacyCodegenAtRuntime=false in dagger.json, the Go SDK trusts
    the committed dagger.gen.go + internal/dagger files and skips the
    in-container codegen pass at runtime (it errors with an actionable message
    if the committed files are missing).
  2. **generate-module runs once for Go modules, in...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dagger-codex[bot]
[dagger/dagger] Pull request opened: #13212 Prototype repo-first Dagger Cloud CLI

Summary

  • add API-backed Dagger Cloud git source inspection/configuration commands
  • add repo-first commands for info, link, unlink, transfer, and autocheck status
  • project linked repos from enabled git sources, with autocheck as a read-only repo setting
  • add dagger integration add github, dagger repo enable autocheck, and a post-login setup hint when a local GitHub repo needs Cloud setup

Verification

  • go test ./internal/cloud ./cmd/dagger -run '^$'
  • `go build -o /tmp/dagge...
vivid lintelBOT
#
dagger-codex[bot]
[dagger/dagger] Pull request opened: #13213 Polish workspace migration

Fixes a few migration issues found while dogfooding module repos.

  • remove dagger workspace init and the matching schema field
  • seed migrated workspace configs without verbose starter comments
  • map the dang runtime to github.com/dagger/dang-sdk
  • report skipped SDK installs in migrated configs and migration reports

Tests:

  • go test ./cmd/dagger -run 'TestRemovedWorkspaceCommands|TestWorkspaceInitCommandRemoved|TestRootHelpShowsWorkspaceCommandGroup|TestWorkspaceFlagPolicy'\n- `go ...
#
dagger-codex[bot]
[dagger/dagger] Pull request opened: #13214 fix: keep migrate lock updates inside changeset

Summary

  • make dagger migrate include planned .dagger/lock writes in the returned changeset instead of staging lock entries during planning
  • merge refreshed migrated lock data into the correct per-plan workspace lock, so nested migrations write nested .dagger/lock files
  • add regression coverage for preview/discard not writing lockfiles and nested pinned refs staying out of the root lock
  • update the workspace upgrade docs from config to settings terminology

Tests

  • `go test...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dagger-codex[bot]
[dagger/dagger] Pull request opened: #13217 feat: support synthetic workspaces

Summary

  • add Query.workspace(directory:) for Directory-backed synthetic workspaces
  • support file, directory, and findUp on rootfs-backed workspaces without host client metadata
  • return explicit errors for unsupported synthetic workspace features and gitignore: true
  • add Go SDK dag.Workspace(dir) plus synthetic workspace coverage

Tests

  • go test ./core/schema
  • go test ./core/integration -run '^$'\n- (cd sdk/go && go test . -run TestWithWorkspace)\n- `go build -o /...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
aluzzardi
[dagger/dagger] Issue opened: #254 input directories are stored using relative paths

Just got the issue using input dir:

$ dagger input dir source ../../

This is what we store:

  "inputs": [
    {
      "key": "source",
      "value": {
        "type": "dir",
        "dir": {
          "path": "../../"
        }
      }
    }
  ]

It's not limited to input dir -- dagger plan dir has the same issue, and I suspect dagger new --plan-dir too.

To fix this once for all, I suggest we resolve the absolute path directly inside `dagger....

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #275 build\(deps\): bump github\.com/stretchr/testify from 1\.5\.1 to 1\.7\.0

Bumps github.com/stretchr/testify from 1.5.1 to 1.7.0.

Release notes
Sourced from github.com/stretchr/testify's releases.

Minor improvements and bug fixes
Minor feature improvements and bug fixes
Fixes breaking change with HTTPBodyContains
A breaking change was accidentally released in v1.6.0 which breaks the API for the HTTPBodyContains and HTTPBodyNotContains, this release reverts that change.
v1.6.0
Latest release of testify. This includes many fixe...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #277 Embed files in a cue package

Sometimes one wants to embed a Dagger deployment plan directly in an application repository, in the same way one might embed a Dockerfile or docker-compose.yaml.

This is currently possible but not seamless. It requires several redundant steps:

  1. The deployment plan declares an input of type artifact. For example source: dagger.#Artifact
  2. Each new deployment must explicitly load the current directory into that input: dagger input dir source .

With embedding, that second step w...

vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Pull request opened: #281 stdlib: rename dagger\.io/llb to dagger\.io/dagger/op

This feels more natural, let me know what you think.

This solves 2 problems:

  1. No more worrying about the technical distinction between llb, buildkit API etc. This was listed as a negative for the dagger.io/llb name, but the pros seemed to outweigh the cons. This could remove the downside without adding new ones.

  2. It opens the possibility of adding base operations that don’t map to llb/buildkit at all. There’s already #DockerBuild which is a higher-level composition of buildki...

vivid lintelBOT
vivid lintelBOT
vast nacelle
#

@snow kayak #272 is rebased

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #287 \`dagger input\` allows invalid inputs

When setting an input value or artifact, for example with dagger input text, the valus is not checked for validity. If I provide an invalid input, this will only be apparent when running dagger up, at which point the context of the original change may be lost.

Example using the “hello-world” example:

$ cd examples/hello-world
$ dagger new
# NOTE: the key ‘message’ will conflict with the input
$ dagger input text message bla
$ dagger up
12:21AM FTL system | failed to up dep...
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #289 \`dagger up\` hangs for 30 seconds or more before returning

As soon as a Dagger configuration is moderately complex, calling dagger up will hang after computing everything, and consume high levels of CPU while not printing anything. Eventually it will return. As the configuration grows in size and complexity, so does the duration of the hang.

This can be reproduced with the dev.cue configuration at the root of the dagger repository; or with examples/react as well.

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #291 “subdir” operation does not work

In certain configurations, the subdir operation is not applied - the result is as if the operation was not there.

Example:

package main

import (
        "dagger.io/dagger"
        "dagger.io/dagger/op"
)

#Container: {
        command: string
        input: dagger.#Artifact | *null

        #up: [
                op.#FetchContainer & {
                        ref: "index.docker.io/alpine"
                },
                op.#Exec & {
                        arg...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #295 Enforce policies with hooks / middleware

As mentioned by @kelseyhightower :) A very successful feature of Kubernetes is the ability to extend it with custom policies out-of-band from actual configurations. So an admin can inject a policy once, and everything will have to run through it.

There are 2 parallel tracks available to implement this:

  1. Cue itself is well suited for policy injection. I defer to @mpvl @myitcv @verdverm for details and examples.
  2. Runtime hooks. This is what Kubernetes does. It could be webhooks; or i...
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #296 Support declarative format for\`\#up\`

Summary

TLDR: the developer experience would be nicer if #up supported a declarative form in addition to an imperative form.

  • Imperative form: array of low-level operations:#up: [...op.#Op]
  • Declarative form: any object with its own nested array: #up: { #up: [...op.#Op], _ }

This is the same pattern as op.#Load.from for example.

Context

Currently any value can be assigned a processing pipeline via the special definition #up. The value of this field must be ...

vivid lintelBOT
vivid lintelBOT
#
TomChv
[dagger/dagger] Pull request opened: #300 \[WIP\] Network local

Solve #237 and add an example to run a configuration that deploy a pod in a KinD kubernetes cluster.

  • Support Entitlements
  • Run configuration in local network
  • Unsafe flags to prevent users from unwanted behavior
  • Run buildkit container in --net=host mode and --allow-insecure-entitlement network.host
vivid lintelBOT
vivid lintelBOT
#
samalba
[dagger/dagger] Issue opened: #303 Export the ref of a pushed image using "push\-container"

ref is an arg of the op.#PushContainer, but there is currently no way to get the full resolved ref of the pushed image (that includes the sha256).

Here is something that should be possible to do:

        source: dagger.#Artifact
        pushTarget: "samalba/myimage:latest"

	ref: {
		string

		#up: [
			op.#DockerBuild & {
				context: source
			},
			op.Export & {
				format: "string"
				source: op.#PushContainer & {
					ref: pushTarget
				}
			}
		]
	}
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #304 “not executable” error on \`op\.\#Load\` \+ default value \+ struct

dagger up fails with “not executable” on certain configurations that should be valid.

The error is triggered by the following conditions:

  1. op.#Load
  2. The from field has a default value, which is used in evaluation
  3. The default value is in the “struct” form from: { #up: [...] }

Here is a repro configuration that shows 4 different load operations. All 4 should be valid, but one fails.

package main

import (
        "dagger.io/dagger/op"
        "dagger.io/dag...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #306 build\(deps\): bump go\.mozilla\.org/sops/v3 from 3\.7\.0 to 3\.7\.1

Bumps go.mozilla.org/sops/v3 from 3.7.0 to 3.7.1.

Release notes
Sourced from go.mozilla.org/sops/v3's releases.

v3.7.1
Commits

[9cc95d4]: Add release workflow (AJ Bahnken) #843
[dfc7af2]: swap to fork of action-automatic-releases (AJ Bahnken) #843
[fdf4517]: Trim space from age keys (Johan Fleury) #846
[1504dbc]: Run CI tests against master as well (AJ Bahnken) #848
[8a2fbc0]: Initial patch for advisory (AJ Bahnken) #852
[e5bf171]: go.sum fix (AJ Bahnken)...

vivid lintelBOT
#
TomChv
[dagger/dagger] Pull request opened: #307 \[WIP\] Kubernetes Stdlib tests

Setup

In order to reach local kubernetes cluster. I've added the flag --net=host on buildkit container.

:warning: Actually, buildkit has an isolation problem, when we use --net=host to run buildkit, it doesn't isolate commands anymore. This bug make this PR possible.

Kubernetes Fix

I also fixed the kubernetes library, there was a problem with source inline :

if sourceInline != _|_ {
  op.#WriteFile & {
    dest:    "/source"
    content: source // Must ...
vivid lintelBOT
vivid lintelBOT
#
aluzzardi
[dagger/dagger] Issue opened: #310 secrets support

#198 added some minimal secrets support in dagger compute, but that's not nearly enough and broken.

Considerations:

  • dagger input secret must provide a secure way to supply and store secrets
  • secrets must be encrypted at rest (e.g. in the state)
  • [Thinking out loud] Just in time Deciphering: Secrets must be encrypted in the Cue tree, decrypted by BuildKit when accessed. This is a safety net to avoid leaking secrets when representing the Cue tree. e.g. mySecret: 42 --> `error: i...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
samalba
[dagger/dagger] Issue opened: #312 No way to know the current deployment based on local path

We need a way to know the current deployment when working from a local directory. For instance a small * or any visual indication when doing dagger list. Otherwise, there is no way to know a given directory is mapped to a deployment.

It would also be nice to know which path is mapped to which deployment.

Example:

$ dagger list
myapp (~/work/myapp)
test (/tmp/thisisatest)
$ cd ~/work/myapp
$ dagger list
myapp (~/work/myapp) - current
test (/tmp/thisisatest)
vivid lintelBOT
vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #315 build\(deps\): bump github\.com/containerd/console from 1\.0\.1 to 1\.0\.2

Bumps github.com/containerd/console from 1.0.1 to 1.0.2.

Release notes
Sourced from github.com/containerd/console's releases.

v1.0.2
Notable changes:

Fix support for big endian architectures such as s390x (containerd/console#51 , thanks to @​kolyshkin)
Support FreeBSD (containerd/console#50 , thanks to @​samuelkarp)

Commits

2f1e3d2 Merge pull request #52 from zhsj/fix-import
63603f4 Add missing import in freebsd nocgo stub
413d286 Merge pull re...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
aluzzardi
[dagger/dagger] Pull request opened: #318 Proper support for Docker Image metadata
  • Both FetchContainer and DockerBuild read the image metadata and
    convert to LLB (e.g. ENV foo bar in Dockerfile shows up in
    op.#Exec)
  • Image metadata is "sticky" between Pipelines (e.g. op.#Load will
    re-use the same metadata)
  • Image metadata is injected back to #PushContainer, so that
    DockerBuild+PushContainer and FetchContainer+PushContainer do not lose
    any metadata.
  • Tests for all the above

Fixes #142

vivid lintelBOT
vivid lintelBOT
#
samalba
[dagger/dagger] Issue opened: #319 stdlib/docker: \#Container\.\#up is very slow on \`cue eval\`

While building the jamstack example, I noticed a cue eval 6x slower (from 0.2s to 1.2 on a MBP with M1), which makes dagger up almost unusable.

After investigating, it looks like the culprit is this for loop: https://github.com/dagger/dagger/blob/2d778ea2a7c4b173c674efbec851b6541b9903e3/stdlib/docker/container.cue#L114

If I comment it, it goes back to normal. As a workaround, I'll move react lib back to the initial implementation.

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
verdverm
[dagger/dagger] Issue opened: #324 Dagger should enable network resilience everywhere

My current build system often fails when a remote network / service behaves badly. 502's, host hangs up, services being down... Today, I have to add custom logic at all of these points as we discover them, or we move to replicating these remotes internally.

  • git clone
  • go mod download
  • docker pull
  • apt update
  • the list goes on and on...

It would be great if there was retry / expo decay options across the building blocks for these situations. Detecting which are network ...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
aluzzardi
[dagger/dagger] Issue opened: #330 Atomic rollouts

When deploying A and B, if A succeeds then B fails the rollout is left as is. This can result in a broken deployment since we now have a new version of A with an old version of B.

Ideally, if a version N of a plan fails, dagger should be re-apply N-1 to bring back A and B to the same version.

/cc @samalba

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
TomChv
[dagger/dagger] Pull request opened: #336 Fix kubernetes skip condition

Change

The old skip condition was cheaking if the name kind exist.

That was not working because every kubeconfig has the field kind: Config.
Example of a common AWS kubeconfig :

apiVersion: v1
clusters:
- cluster:
   
- context:
    
current-context: ...
kind: Config # the field
preferences: {}
users:

I changed the condition to match the field user: kind-kind, which is the default user for all kind kubeconfig.
I also check that cluster is runnin...

vivid lintelBOT
vivid lintelBOT
#
samalba
[dagger/dagger] Pull request opened: #338 Pushcontainer image ref

This is a proposal that fixes #303

The change allows certain ops to export meta data to the image fs, under /dagger/. We could reuse the same mechanism for fetch-git to write things like /dagger/commit or /dagger/remote, etc...

I was initially not ok to alter the pushed image, but after testing it, I think it's fine as the pushed image does not contain the meta-data. It's only available within the #up pipeline.

Also, I like the fact that it does not break the current `op.#...

vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #340 build\(deps\): bump github\.com/uber/jaeger\-client\-go from 2\.25\.0\+incompatible to 2\.26\.0\+incompatible

Bumps github.com/uber/jaeger-client-go from 2.25.0+incompatible to 2.26.0+incompatible.

Release notes
Sourced from github.com/uber/jaeger-client-go's releases.

Release 2.26.0

Delete a baggage item when value is blank (#562) -- evan.kim
Trim baggage key when parsing (#566) -- sicong.huang
feat: extend configuration to support custom randomNumber func (#555) -- NemoO_o
Support JAEGER_TRACEID_128BIT env var (#547) -- Yuri Shkuro
Additional context p...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Pull request opened: #347 stdlib: dagger\.io/dagger/op: stricter typing for load, mount, copy

This removes the untyped from: _ fields in operations that reference other operations. Specifically:

  • Load from ...
  • Copy from ...
  • Exec with mounts from ...
  • Dockerbuild with context from ...

By embedding the smallest possible #Runnable definition directly in the dagger.io/dagger/op package, we avoid circular imports. It makes sense for op to have its own internal definition of what is runnable. Higher-level packages may use it, but don’t have to.

vivid lintelBOT
vivid lintelBOT
#
TomChv
[dagger/dagger] Pull request opened: #350 Tests AWS Eks

TL;DR

  • Add tests on AWS eks
  • Fix kubeconfig type from aws/eks package

Tests made

  • Verify that we can execute a kubectl get pods -A on the aws cluster

It's not necessary to do more, we already wrote tests for kubernetes.

Fix

There is a problem with the dagger.#Secret type. It wasn't possible to generate the kubeconfig.

Click to see an example
Here is a simple example :

import (
	"dagger.io/aws"
	"dagger.io/dagger/op"
)

#Def: {
	...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #357 Unique environment ID

Each dagger environment (aka deployment) has a simple name that is only unique locally. There should also be a globally unique ID for each environment. This ID should not depend on the simple name.

If the ID is derived from a unique per-environment keypair (eg. ID = hash of the pubkey), then we can use that keypair as a foundation for very promising features: cryptographic access control; content trust via TUF; etc.

vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #358 Unique artifact ID

Problem

Currently input artifacts (local directories, git repositories, docker repositories) are identified only by how to access them in their respective address spaces. Local dir is identified by its local path; git repo by its git remote and ref; etc.

This poses a problem specifically for local directories, because it is common for a directory to be moved to a different path. Currently dagger cannot differentiate between a directory changing path, and a directory being destroyed. I...

vivid lintelBOT
#
shykes
[dagger] New discussion #360: Terminology

This is a thread to discuss Dagger’s terminology (the choice of specific words to designate specific things), our experience with it, suggestions for changing it, etc.

Dagger’s terminology is still changing rapidly. Product terminology is part of product design, and the only way to find the right design is to try lots of bad ones. So, we’ve been trying lots of words to describe the important parts of Dagger. As we use the product, we get a better idea of which words work and which don’t.
...

#
shykes
[dagger/dagger] New comment on discussion #360: Terminology

After a few weeks of feedback and hands-on practice, I am leaning towards the following changes:

  • Deployment: a continuously running workflow delivering a specific application in a specific way.

Rename to Environment.

  • Deployment Plan: the source code of the deployment, written in Cue.

Rename to Workflow.

Rationale for environment:

  • It comes up all the time in natural conversation. No matter what the terminology says, I end up using the word “environment” to e...
vivid lintelBOT
#
shykes
[dagger] New discussion #362: Embedding dagger configuration in an application repo

I have observed 2 distinct patterns for how to use Dagger in combination with an application repository:

  1. Embedded. Sometimes one wants to embed a Dagger workflow directly in an application repository, in the same way one might embed a Dockerfile or docker-compose.yaml.

  2. Standalone. Sometimes one wants to develop a Dagger workflow separately, from any application repository.

How Dagger supports these two patterns, and how to make sure each user follows the correct pattern for...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
TomChv
[dagger/dagger] Issue opened: #364 Unset input on deployment

Problem

Actually, it's not possible to remove an input from a deployment and that's really frustrating...
Imagine an user who do a typo when adding an input ? He will not delete the deployment and restart all from the beggining.

Proposal

Add a flag unset on dagger input which take the cue path as argument and remove the input

Example

$ dagger input text name "John Doe"
updated deployment...

$ dagger input list
Saved Inputs:
name: {text    0xc00061...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
aluzzardi
[dagger/dagger] Pull request opened: #369 \[POC\] dagger: down

POC: For discussions only

This is a fully functional POC of dagger down working with examples/react

How it works

There's many ways to do this, I went with one that seemed to work, very open to suggestions.

Here's how this approach works (look at stdlib/netlify, stdlib/react and examples/react to see it in action):

  • We're back with #compute
  • There's a new #hooks that contains both up and down
  • On dagger up, every #compute is executed, along wi...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
TomChv
[dagger/dagger] Pull request opened: #371 Update ops tests

TL;DR

  • Rename all tests with prefix Test
  • Trigger some test which works now
  • Add more test to op.#Subdir
  • Rename some package testing

Tests Convention

All tests in operations where outdated and doesn't respect the naming convention. I walk through all ops tests to fix name and sometimes tests.

Changes

op.#Load

  • Rename Test
  • Trigger

op.#Mount

  • Rename test
  • Add some asserts
  • Update tests : #46 is fixed

op.#Copy

  • Rename test
    ...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #382 build\(deps\): bump google\.golang\.org/grpc from 1\.29\.1 to 1\.37\.0

Bumps google.golang.org/grpc from 1.29.1 to 1.37.0.

Release notes
Sourced from google.golang.org/grpc's releases.

Release 1.37.0
API Changes

balancer: Add UpdateAddresses() to balancer.ClientConn interface (#4215)

NOTICE: balancer.SubConn.UpdateAddresses() is now deprecated and will be REMOVED in gRPC-Go 1.39

Behavior Changes

balancer/base: keep address attributes for pickers (#4253)

Special Thanks: @​longXboy

New Features

xds: add support for c...

vivid lintelBOT
vivid lintelBOT
#
eliecharra
[dagger/dagger] Pull request opened: #383 S3 does not update object if rollbacked to an existing layer

Fix a bug where you are locked with inconsistency between your intention and the reality.

How to reproduce

  • cd example/simple-s3
  • dagger up
  • Modify the html body
  • dagger up
  • Rollback the body to a previously deployed version (Ctrl+Z)
  • dagger up
  • Nothing is sent to S3

We cannot reuse the buildkit caching logic, maybe a more efficient way to achieve a proper caching could be to compare a checksum of local object and remote one.

vivid lintelBOT
vivid lintelBOT
#
TomChv
[dagger/dagger] Pull request opened: #385 Dagger: unset input

TL;DR

Resolve #364

Changes

Features

It's now possible to remove input from environement through dagger input unset .
@aluzzardi has already develop the feature in dagger. I've only linked it to CLI.

Tests

All input tests now unset the input after run.
It was the simplest and more effective way to test all types of input with unset command.

vivid lintelBOT
#
shykes
[dagger/dagger] Pull request opened: #387 POC: extreme git flow

This is a proof-of-concept of a Dagger implementation optimized for integration with an existing git flow. In this implementation, all Dagger state is embedded in a git repository.

Usage example:

$ alias dgr=$(pwd)/cmd/dgr
$ dgr list
dev
hello-world
release
$ dgr dir dev source .
$ dgr up dev
$ dgr query dev
$ dgr set hello-world name ‘“Bob”’
$ dgr query hello-world msg
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #394 build\(deps\): bump github\.com/moby/buildkit from 0\.8\.2 to 0\.8\.3

Bumps github.com/moby/buildkit from 0.8.2 to 0.8.3.

Release notes
Sourced from github.com/moby/buildkit's releases.

v0.8.3
https://hub.docker.com/r/moby/buildkit
Notable changes

Update containerd with fixes to rootless overlay on kernel 5.11 and push panic #2014

Add retry on 5xx push errors moby/buildkit#2043

Include basename in content checksum for wildcards #2018

Fix missing mounts in execOp cache map #2076

Commits

81c2cbd Merge pull reque...

vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #395 Allow inline pipelines

Currently Dagger does not support inlining pipelines. For example:

This works:

import (
    “dagger.io/dagger/op”
)

// Intermediary pipeline cannot be inlined: it must be visible in a field
sayHello: {
    message: {
        string
        #up: [
            op.#FetchContainer & { ref: “alpine” },
            op.#Exec & { args: [“sh”, “-c”, “echo hello” > /message”],
            op.#Export & { source: “/message”, format: “string” },
        ]
    }
}

hello: sayHel...
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #396 Easy way to lock git or docker ref by digest

Sometimes my configuration fetches a git or docker repository without specifying a digest, and I want to add the current digest to avoid unexpected changes in the future. But how do I find out the current digest? Dagger does not provide a command to do this. I have to search for specialized tooling and learn how to use it, just to get that ref.

Since git and docker refs and digests are important concepts in Dagger, it makes sense for the dagger command to make it easy to manage digests.

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
aluzzardi
[dagger/dagger] Issue opened: #399 regression with buildkit 0\.8\.3

As reported by @TomChv, it appears there's a regression with buildkit 0.8.3.

9:35PM FTL system | failed to up environment: buildkit solve: TestECR.creds.secret: 2 errors in empty disjunction:
TestECR.creds.secret: conflicting values "XXX" and "XXX":
    /config/cue.mod/pkg/dagger.io/aws/ecr/ecr.cue:17:12
    /config/ecr.cue:32:9
TestECR.creds.secret: conflicting values string and bytes (mismatched types string and bytes):
    /config/cue.mod/pkg/dagger.io/aws/aws.cue:63:3
    /c...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #413 build\(deps\): bump github\.com/uber/jaeger\-client\-go from 2\.27\.0\+incompatible to 2\.28\.0\+incompatible

Bumps github.com/uber/jaeger-client-go from 2.27.0+incompatible to 2.28.0+incompatible.

Release notes
Sourced from github.com/uber/jaeger-client-go's releases.

Release 2.28.0

HTTPSamplingStrategyFetcher: Use http client with 10 second timeout (#578) -- Joe Elliott

Changelog
Sourced from github.com/uber/jaeger-client-go's changelog.

Changes by Version
2.28.1 (unreleased)

Nothing yet

2.28.0 (2021-04-30)

HTTPSamplingStrategyFetcher: Use http...

#
dependabot[bot]
[dagger/dagger] Pull request opened: #414 build\(deps\): bump github\.com/moby/buildkit from 0\.8\.2 to 0\.8\.3

Bumps github.com/moby/buildkit from 0.8.2 to 0.8.3.

Release notes
Sourced from github.com/moby/buildkit's releases.

v0.8.3
https://hub.docker.com/r/moby/buildkit
Notable changes

Update containerd with fixes to rootless overlay on kernel 5.11 and push panic #2014

Add retry on 5xx push errors moby/buildkit#2043

Include basename in content checksum for wildcards #2018

Fix missing mounts in execOp cache map #2076

Commits

81c2cbd Merge pull reque...

vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #415 Graceful handling of API changes in stdlib

Sometimes APIs will change in the stdlib. The bigger the stdlib, the more certain this is. Sometimes the API change is a mistake which needs to be caught and rolled back. Sometimes it is intentional, because the package is still young and needs to continue evolving. In both cases, the experience for end users and developers should be good.

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
aluzzardi
[dagger/dagger] Issue opened: #422 references appear to be re\-executed

We don't do any kind of de-duplication and instead rely on buildkit to avoid executing pipelines multiple times when referred.

This is slightly confusing in how the information is presented.

For instance, given this config:

ActuallyDoStuff: #up: [some code here]
TestReference: ActuallyDoStuff
TestAnotherReference: TestReference

3 pipelines will show up:

6:43PM INF ActuallyDoStuff | computing
6:43PM INF ActuallyDoStuff | completed    duration=700ms
6:43PM INF Test...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
TomChv
[dagger/dagger] Pull request opened: #425 Check dagger version periodically

TL;DR

  • Check each 24h dagger binary version and notice user if an update is available
  • Add a --check flag to dagger version to verify that dagger is up to date manually.
  • Update documentation to explain update steps

Changes

Hooks

I've added a PreRun and PostRun hooks to dagger cli in order to check periodically dagger version.
It will compare the dagger binary version with the latest version.

If the u...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dubo-dubon-duponey
[dagger/dagger] Issue opened: #427 Panic

Currently on 09b614f3ffe18451dcdff8ddae8b37a91f07e54f

dmp@macArena:~/Projects/Go/src/github.com/blocklayerhq/dagger$ ./cmd/dagger/dagger compute --input-dir=../context .
panic: runtime error: index out of range [1] with length 1

goroutine 1 [running]:
dagger.io/go/cmd/dagger/cmd.glob..func2(0x2bd4f60, 0xc0005a0120, 0x1, 0x2)
	/Users/dmp/Projects/Go/src/github.com/blocklayerhq/dagger/cmd/dagger/cmd/compute.go:59 +0x25f6
github.com/spf13/cobra.(*Command).execute(0x2bd4f60, 0xc000...
vivid lintelBOT
#
dubo-dubon-duponey
[dagger/dagger] Issue opened: #428 dockerfilePath appears to be misleading or not implemented as it should

#DockerBuild.dockerfilePath (apparently: https://github.com/dagger/dagger/blob/62eedd647039f9d237b5be4609f4fe6cb1cda3c8/dagger/pipeline.go#L815) translate to --option filename (for buildkit), hence allows simply to specify an alternative name for the Dockerfile, and not to specify an actual path (that part would translate to --local dockerfile= IIRC and seem to be missing).

Looking at https://github.com/dagger/dagger/blob/c8dbbaa1c6c585c9a44b68b1e55deaeb9709ef9f/tests/ops/dockerbuil...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dubo-dubon-duponey
[dagger/dagger] Issue opened: #437 \#DockerBuild\.platforms seems to be non\-functioning 
package cake

import (
	"dagger.io/dagger/op"
)

mybuild: #up: [
	op.#DockerBuild & {
		dockerfile: """
		FROM debian
		"""
		platforms: ["linux/amd64", "linux/arm64"]
	},
]


6:22PM FTL system | failed to up environment: buildkit solve: task failed: invalid map result

Buildkitd output the same (unhelpful) message:

ERRO[0010] /moby.buildkit.v1.Control/Solve returned error: rpc error: code = Unknown desc = task failed: invalid map result

T...

vivid lintelBOT
vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #439 build\(deps\): bump github\.com/hashicorp/go\-version from 1\.2\.1 to 1\.3\.0

Bumps github.com/hashicorp/go-version from 1.2.1 to 1.3.0.

Release notes
Sourced from github.com/hashicorp/go-version's releases.

v1.3.0
FEATURES:

Add Core function to return a version without prerelease or metadata (#85)

Changelog
Sourced from github.com/hashicorp/go-version's changelog.

1.3.0 (March 31, 2021)
Please note that CHANGELOG.md does not exist in the source code prior to this release.
FEATURES:

Add Core function to return a versi...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #445 Execution time grows logarithmically with config size

It appears that execution time for dagger up grows logarithmically with configuration size. When a configuration reaches medium-to-large size, dagger up can take several minutes to complete.

This issue can be found, in a more moderate form, when running cue eval.

There are many ongoing discussions and investigations related to this issue. If possible, please refer them here, so we can have all information in one place, and discuss how to fix it.

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dubo-dubon-duponey
[dagger/dagger] Issue opened: #451 SIGSEGV on load plan

Here is my environment:

dmp@macArena:~/Projects/Go/src/github.com/blocklayerhq/dagger$ cat ~/.dagger/store/docker-elastic/deployment.json
{
  "id": "4d81378c-db20-45fb-a15d-df768d5d336e",
  "name": "docker-elastic",
  "plan": {
    "type": "dir",
    "dir": {
      "path": "/Users/dmp/Projects/Distribution/docker-images/infrastructure/docker-elastic",
      "include": [
        "*.cue",
        "cue.mod"
      ]
    }
  },
  "inputs": [
    {
      "key": "Root",
    ...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
aluzzardi
[dagger/dagger] Pull request opened: #459 gitflow

dagger now stores its state alongside the plan.

To initialize an environment, dagger init must be run once:

$ cd ~/work/dagger/examples/react
$ dagger init
$ tree -a .dagger
.dagger
├── .gitignore
├── state
│   └── computed.json
└── values.yaml
$ cat .dagger/values.yaml
name: react

# share the state
$ git add .dagger
$ git commit -m ...

NOTE .dagger/state contains internal state (e.g. computed values).
A .gitignore is automatically generated to avoid committing it.

This...

vivid lintelBOT
#
ajeetraina
[dagger/dagger] Issue opened: #460 The dagger version CLI doesn't require the Global Flags and hence should be removed from the help page

Environment

  • Macbook Pro Catalina
  • Dagger Release Version
dagger version --check
dagger version 0.1.0-alpha.5 darwin/amd64
dagger is up to date.

Issue

The dagger version CLI doesn't require the Global Flags and hence should be removed.

dagger help version
Print dagger version

Usage:
  dagger version [flags]

Flags:
      --check   check if dagger is up to date
  -h, --help    help for version

Global Flags:
  -e, --environment string ...
vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #461 build\(deps\): bump google\.golang\.org/grpc from 1\.37\.0 to 1\.37\.1

Bumps google.golang.org/grpc from 1.37.0 to 1.37.1.

Release notes
Sourced from google.golang.org/grpc's releases.

Release 1.37.1

client: fix rare panic when shutting down client while receiving the first name resolver update (#4398)
client: fix leaked addrConn struct when addresses are updated (#4347)
xds/resolver: prevent panic when two LDS updates are receives without RDS in between (#4327)

Commits

64031cb Change version to 1.37.1 (#4415)
ef64e13 v...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #465 build\(deps\): bump github\.com/rs/zerolog from 1\.21\.0 to 1\.22\.0

Bumps github.com/rs/zerolog from 1.21.0 to 1.22.0.

Commits

3c3b4a3 Add ability to customize level values
4de2fcc Fix handling of printing caller with Write, Print, and Printf. (#315)
f09463f Migrate to github actions
19c98f6 If LevelFieldName is empty don't log level (#313)
0f923d7 Fix: mutil.fancyWriter.ReadFrom records number of bytes written (#256)
582f0cf add Disabled to String and ParseLevel; add tests (#307)
98f889f Revert "Fix Typo (#306)"
f...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #473 Upcoming Cue language change might break Dagger configurations

There is an upcoming change in the Cue language, that could impact Dagger. The change concerns “closedness rules”: what operations are or aren’t allowed on a value once it is closed. Currently a closed struct may not have new fields added, but it may have new definitions added. With the proposed change, new definitions will not be allowed either. This could potentially affect Dagger since we rely on the ability to add a definition called #up to values.

Currently the impact of this change...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #474 build\(deps\): bump github\.com/cli/cli from 1\.9\.2 to 1\.10\.0

Bumps github.com/cli/cli from 1.9.2 to 1.10.0.

Release notes
Sourced from github.com/cli/cli's releases.

GitHub CLI 1.10.0
Improvements to JSON exporting

Add gh repo list/view --json support cli/cli#3627

Add gh release view --json support cli/cli#3656

Fixes numerous issues with gh pr list/view --json support #3547

fetching closed field
fetching date fields like createdAt or mergedAt
fetching files field

Fix exporting milestone field for issues and PR...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #478 build\(deps\): bump google\.golang\.org/grpc from 1\.37\.1 to 1\.38\.0

Bumps google.golang.org/grpc from 1.37.1 to 1.38.0.

Release notes
Sourced from google.golang.org/grpc's releases.

Release 1.38.0
API Changes

reflection: accept interface instead of grpc.Server struct in Register() (#4340)
resolver: add error return value from ClientConn.UpdateState (#4270)

Behavior Changes

client: do not poll name resolver when errors or bad updates are reported (#4270)
transport: InTapHandle may return RPC status errors; no longer RST_...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #482 build\(deps\): bump github\.com/uber/jaeger\-client\-go from 2\.28\.0\+incompatible to 2\.29\.0\+incompatible

Bumps github.com/uber/jaeger-client-go from 2.28.0+incompatible to 2.29.0+incompatible.

Release notes
Sourced from github.com/uber/jaeger-client-go's releases.

Release 2.29.0

Update vendored thrift to 0.14.1 (#584) -- @​nhatthm

Changelog
Sourced from github.com/uber/jaeger-client-go's changelog.

Changes by Version
2.29.1 (unreleased)

Nothing yet.

2.29.0 (2021-05-20)

Update vendored thrift to 0.14.1 (#584) -- @​nhatthm

2.28.0 (2021-04-30)...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #493 Some cue errors are not caught before running

One big selling point of Cue is that you can catch many errors in your configuration before applying it. However, certain errors which should be caught before running (or at least feel like they should be caught), are not.

So far I have identified one category of errors which is not caught by Cue before execution:

  • References to a non-existing definition in an imported package

For example, I expect this snippet to fail before execution, but it does not:

import (
   “str...
vivid lintelBOT
vivid lintelBOT
#
aluzzardi
[dagger/dagger] Issue opened: #495 Broken BuildKit deduplication when using cache mounts

We've had a regression since BuildKit 0.8.3: when using cache mounts, pipelines get executed multiple times (each time they're referenced).

This is because we use the cue value path as "cache key".

https://github.com/dagger/dagger/pull/414 implemented a workaround: if the value is a reference, use the reference as the "cache key" rather than the value itself (see https://github.com/dagger/dagger/pull/414/files#diff-12b33ae88bbb59b957748ffced0d12a6a6248013fc81d342fdc44343ce2c692cR441 `ca...

vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #496 build\(deps\): bump github\.com/uber/jaeger\-client\-go from 2\.29\.0\+incompatible to 2\.29\.1\+incompatible

Bumps github.com/uber/jaeger-client-go from 2.29.0+incompatible to 2.29.1+incompatible.

Release notes
Sourced from github.com/uber/jaeger-client-go's releases.

Release 2.29.1

Remove dependency on "testing" in "thrift" (#586) -- @​yurishkuro

Changelog
Sourced from github.com/uber/jaeger-client-go's changelog.

Changes by Version
2.29.2 (unreleased)

Nothing yet.

2.29.1 (2021-05-24)

Remove dependency on "testing"...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
grouville
[dagger/dagger] Issue opened: #506 Inconsistent names in menubar | Doc website

When arriving on the doc website, we can see, on the left, the menubar of all the accessible pages for a given version

Devel version, left menubar

Introduction
Install Dagger <==
Dagger vs. Other software <== 
GUIDES
Programming Guide
Operator Manual
COMMUNITY <==
GitHub
Discord

All other alpha versions, left menubar

Introduction
Getting started <==
Dagger vs. Other <==
GUIDES
Programming Guide
Operator Manual
MORE <==
GitHub
Discord

Plus...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
dependabot[bot]
[dagger/dagger] Pull request opened: #510 build\(deps\): bump filippo\.io/age from 1\.0\.0\-rc\.1 to 1\.0\.0\-rc\.2

Bumps filippo.io/age from 1.0.0-rc.1 to 1.0.0-rc.2.

Release notes
Sourced from filippo.io/age's releases.

The last (?) v1.0.0 release candidate!
This is it! The v1.0.0 milestone is empty. Will let it simmer for a bit and then we'll have v1.0.0. Please test it!
Main changes
🤏 Reject RSA keys (for ssh-rsa) smaller than 2048 bits (#266)
🥞 Remove limit of 20 recipients per file (#139)
📜 Add age(1) and age-keygen(1) man pages (#131) — read them here!
⚔️ ...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
TomChv
[dagger/dagger] Pull request opened: #512 Buildkit secrets supports

Secrets are never exposed in plaintext in the Cue tree. dagger query
won't dump secrets anymore, Cue errors won't contain them either.
BuildKit-native secrets support through a new mount type. This
ensures secrets will never be part of containerd layers, buildkit
cache and generally speaking will never be saved to disk in plaintext.
Updated netlify as an example
Added tests
Changed the Cue definition of a secret to:
@dagger(secret)

    id: string

}
This is to ensure ...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
snow kayak
#

@quaint umbra ^^^ FYI, added discord notifications for the example repo

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
aluzzardi
[dagger/dagger] Pull request opened: #524 dagger input edit

dagger input edit: view and edit all inputs in bulk using a text editor

Day to day it's a PITA to use dagger input *, I ended up relying a lot on my shell history. Changing an input requires re-typing the whole thing (e.g. adding an exclude to a dir, changing the branch of a git input, ...). Renaming an input requires unsetting it and then setting it back to a different key with the same arguments, etc.

Demo:

[asciicast](h...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
TomChv
[dagger/dagger] Pull request opened: #528 Update sops version to fix CI

Changes

There was a problem with #512 CI, some tests were skipped because sops couldn't read inputs.yaml.

Here is the trace

With @grouville, we explored that problem and discovered that it was just the sops version that was outdated 3.6.1 -> 3.7.1.

:warning: We should take care about that kind of problems because there were some tests that failed for people with the latest version (but not in the...

vivid lintelBOT
#
dependabot[bot]
[dagger/examples] Pull request opened: #3 Bump ws from 7\.4\.2 to 7\.4\.6 in /voteapp/result

Bumps ws from 7.4.2 to 7.4.6.

Release notes
Sourced from ws's releases.

7.4.6
Bug fixes

Fixed a ReDoS vulnerability (00c425ec).

A specially crafted value of the Sec-Websocket-Protocol header could be used
to significantly slow down a ws server.
for (const length of [1000, 2000, 4000, 8000, 16000, 32000]) {
const value = 'b' + ' '.repeat(length) + 'x';
const start = process.hrtime.bigint();
value.trim().split(/ *, */);
const end = process.hrtime.bigi...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #532 failed to load environment: unable to decrypt state: Error getting data key: 0 successful groups required, got 0

When running dagger list in a workspace for which I don’t have the private key, the following error appears: failed to load environment: unable to decrypt state: Error getting data key: 0 successful groups required, got 0.

To reproduce, fetch the dagger examples repo, and try to use it:

$ git clone https://github.com/dagger/examples
$ cd examples/helloapp
$ dagger list
3:14PM ERR system | failed to load environment: unable to decrypt state: Error getting data key: 0 successf...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
aluzzardi
[dagger/dagger] Pull request opened: #535 use ~/\.config/dagger rather than ~/\.dagger

since .dagger directories have a special meaning now because of gitflow,
it's better not to have a ~/.dagger since it's not a workspace and
it confuses dagger (e.g. dagger new from $HOME).

We don't store state there anymore, just keys and the last version
check, so it's okay to be in ~/.config IMO

Looking at my system, in ~/.config there's gcloud, gatsby, gh,
yarn, and others so it seems like a pretty common location.

Signed-off-by: Andrea Luzzardi

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #538 Remove dependency on \`docker\` client binary

In some situations, Dagger needs to talk to a Docker daemon to setup its buildkit environment. Currently it does this by shelling out to the docker command. If the docker command is not installed, Dagger will fail (see #533). This can be solved by implementing the required Docker client calls directly in the dagger binary (using a Docker client library). This will guarantee that Dagger can always setup its buildkit environment when a Docker daemon is available, even when the docker cl...

#
shykes
[dagger/dagger] Issue opened: #540 Universe packages should respect Cue development workflow

Currently Dagger’s “universe” (standard library of packages) does not follow the standard Cue development workflow:

  • If a cue configuration imports a Dagger Universe package (dagger.io/…), cue eval will not work out of the box.
  • Packages cannot be installed or upgraded individually
  • Packages are loaded at runtime by the dagger command. They are not available to the developer in their cue.mod directory, or anywhere else on the local system.
  • There is no versioning. Users cann...
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #541 Prefix unstable packages with /alpha or /beta

Most packages in the Dagger “universe” are not yet stable, and the import path should reflect that. One possible inspiration is kubernetes resource naming. When resources are not yet stable, their canonical name includes “alpha” or “beta”, for example: service.beta.kubernetes.io/aws-load-balancer-ssl-cert.

In our case, instead of this:

import (
  “dagger.io/os”
  “dagger.io/dagger”
  “dagger.io/dagger/op”

)

We might use:

import (
  “dagger.io/alpha/os”
  “...
vivid lintelBOT
#
shykes
[dagger/examples] Issue opened: #7 voteapp fails with cue error related to ECS and Cloudformation 
$ cd voteapp
$ dagger up
1:33PM FTL system | failed to query environment: plan config: #ECSApp.cfnStack.outputs.#up.6.env.AWS_ACCESS_KEY_ID: conflicting values string and {id:string} (mismatched types string and struct):
    /config/cue.mod/pkg/dagger.io/aws/aws.cue:14:13
    /config/cue.mod/pkg/dagger.io/aws/cloudformation/cloudformation.cue:78:28
    /config/cue.mod/pkg/dagger.io/dagger/dagger.cue:18:10
    /config/cue.mod/pkg/dagger.io/dagger/op/op.cue:46:18
    /config/ecs.cue...
#
shykes
[dagger/dagger] Issue opened: #543 Distinguish core packages from “universe” packages

Dagger distributes several Cue packages for use by the Dagger developer community. There are 2 types of packages:

  • Core packages, which expose features of Dagger itself. Currently those are dagger.io/os, dagger.io/file, dagger.io/dagger and dagger.io/dagger/op. This may change in the future (possible by merging these packages into one).

  • “Universe” packages, which implement useful components to be reused by others in the community. For example AWS integration, Netlify integrat...

vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #546 stdlib: fix os\.\#Container secrets API for consistency

Secrets support in os.#Container is not consistent with other mounts:

  • Tmpfs: #Container.tmpfs[“/foo”]
  • Cache: #Container.cache[“/foo”]
  • Artifact: #Container.mount[“/foo”]
  • Secret: #Container.mount[“/foo”]. Following the pattern from the other 3, it should be #Container.secret[“/foo”]

https://github.com/dagger/dagger/blob/c4162b1e98d0d795286c55a172e496a0afd37bd4/stdlib/os/container.cue#L52-L63

vivid lintelBOT
vivid lintelBOT
#
grouville
[dagger/dagger] Issue opened: #548 \`dagger up\` doesn't rerun buildkit after a manual stop of it's container

After spawning some tty blocking #op.Exec commands inside Buildkit for some tests. I wasn't sure if they were still processing in the background.

I manually stopped the buildkit container, then dagger up again. However, it didn't reconnect to the built container, neither creates a new one. The only way is to delete the container and rerun dagger up. Btw, jaegertracing also interferes with the rerun, it shall be stopped also

Proof :

➜ docker ps
CONTAINER ID   IMAGE        ...
vivid lintelBOT
vivid lintelBOT
#
aluzzardi
[dagger/dagger] Issue opened: #552 stdlib: docker\.\#Push missing features

1. docker.#Push doesn't support authenticated pushes (and therefore cannot work, unless pushing to a local unauthenticated registry).

Support was added in #373 in op.#DockerLogin.

Either docker.#Push takes credentials or we expose a docker.#Login component.

2. docker.#Push doesn't export the reference/digest of what was just pushed. Support was added to op.#PushContainer in #303. I suggest docker.#Push takes a name as an input and has a ref and digest as outputs...

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
shykes
[dagger/dagger] Issue opened: #566 \`dagger up\` shows all intermediary outputs

dagger up now prints the environment’s outputs, which is very useful. However, there is no distinction between “final” outputs and “intermediary” outputs (because we don’t know how to make that distinction). As a result, a typical configuration will print intermediary outputs which are 1) not useful to the end user, and 2) confusing because their contents are obscure.

For example, see voteapp in https://github.com/dagger/examples

vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
#
TomChv
[dagger/dagger] Pull request opened: #572 \[WIP\] Add Docker compose package

TL;DR

  • Add #Up in docker/compose package
  • Add #Client in docker/compose package
  • Add tests for docker-compose package

Changes

I took hover the docker.#Run definition to create compose.#Up. There is nothing different about ssh connection.

:warning: We musn't forget to update both packages if we modify something about ssh connection.

We can call ``#Up docker-compose one (or both) of those arguments :

  • a docker-compose.yaml in composeFile
    ...
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT
vivid lintelBOT