Skip to content
Draft
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
31 commits
Select commit Hold shift + click to select a range
92ceb40
test(dependencies): add provider dependency contract fixtures
skevetter Oct 19, 2026
1ccf702
test(dependencies): enforce fixture validation constraints
skevetter Oct 19, 2026
9c477d3
test(dependencies): add effect and lock safety guards
skevetter Oct 19, 2026
b29a938
feat(dependencies): add dependency store path roots
skevetter Oct 19, 2026
ea535da
feat(dependencies): add disabled provider requirement catalog
skevetter Oct 19, 2026
aa39b97
feat(dependencies): add passive executable lookup
skevetter Oct 19, 2026
9fe7854
feat(dependencies): add strict metadata codecs and atomic writes
skevetter Oct 19, 2026
d2d69c6
feat(dependencies): survey requirements without execution
skevetter Oct 19, 2026
520a346
feat(dependencies): translate built-in provider snapshots for survey
skevetter Oct 19, 2026
18c74eb
feat(config): resolve dependency paths without creating directories
skevetter Oct 19, 2026
29d0d4f
feat(dependencies): load snapshots with explicit path managers
skevetter Oct 19, 2026
b128a74
feat(dependencies): resolve read-only paths with explicit home
skevetter Oct 19, 2026
907d773
feat(dependencies): inspect deletion fence with explicit paths
skevetter Oct 19, 2026
4453a6a
feat(dependencies): add passive CLI startup policy
skevetter Oct 19, 2026
9eb610d
feat(dependencies): prepare static provider inspection inputs
skevetter Oct 19, 2026
a77908e
chore(dependencies): sync upstream platform identifiers
skevetter Oct 20, 2026
ce08de9
feat(dependencies): format passive inspection reports
skevetter Oct 20, 2026
41ec23c
fix(platform): defer private cache creation until save
skevetter Oct 20, 2026
0609cee
feat(dependencies): add passive provider inspection command
skevetter Oct 20, 2026
9b1d525
chore: integrate main into provider dependency work
skevetter Nov 2, 2026
b20408f
feat(dependencies): expose passive inspection in Desktop
skevetter Nov 2, 2026
a8f5308
refactor(desktop): isolate IPC validation and provider selection
skevetter Nov 3, 2026
fbdda91
test(dependencies): remove pinned catalog snapshot assertions
skevetter Nov 3, 2026
af5e26f
style: normalize merged Go files for precommit
skevetter Nov 3, 2026
603f62a
test(dependencies): respect Windows lookup candidates
skevetter Nov 3, 2026
2924c8a
chore: merge current main into dependency branch
skevetter Nov 3, 2026
18017a5
test(dependencies): reuse existing empty case label
skevetter Nov 3, 2026
11d401a
test(ci): isolate nested process build from package matrix
skevetter Nov 3, 2026
57ec879
chore: merge current main into dependency branch
skevetter Nov 3, 2026
682695f
test(ci): isolate shipped CLI builds from package matrix
skevetter Nov 3, 2026
fb202c7
fix(dependencies): accept generated installed icon revisions
skevetter Nov 3, 2026
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 10 additions & 2 deletions cmd/container_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -23,8 +23,16 @@ func TestContainerInfoFailureRendering(t *testing.T) {
var out bytes.Buffer
root.SetOut(&out)
root.SetArgs([]string{
containerCommandName, infoCommandName, "--home", t.TempDir(),
"--context", "not-configured", "--provider", "not-configured", "--result-format", "json",
containerCommandName,
infoCommandName,
"--home",
t.TempDir(),
"--context",
"not-configured",
passiveTestProviderFlag,
"not-configured",
"--result-format",
"json",
})
err := root.Execute()
require.ErrorContains(t, err, config.EnvWorkspaceID)
Expand Down
17 changes: 17 additions & 0 deletions cmd/dependency/dependency.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,17 @@
// Package dependency provides passive inspection of installed provider dependencies.
package dependency

import (
"github.com/devsy-org/devsy/cmd/flags"
"github.com/spf13/cobra"
)

func NewDependencyCmd(globalFlags *flags.GlobalFlags) *cobra.Command {
command := &cobra.Command{
Use: "dependency", Short: "Inspect installed provider dependencies",
}
flags.MarkPassive(command)
flags.MarkDependencyInspection(command)
command.AddCommand(newInspectCmd(globalFlags))
return command
}
326 changes: 326 additions & 0 deletions cmd/dependency/inspect.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,326 @@
package dependency

import (
"context"
"encoding/json"
"errors"
"fmt"
"os"
"runtime"
"time"

"github.com/devsy-org/devsy/cmd/flags"
"github.com/devsy-org/devsy/pkg/clierr"
"github.com/devsy-org/devsy/pkg/config"
"github.com/devsy-org/devsy/pkg/dependencies"
"github.com/devsy-org/devsy/pkg/output"
"github.com/devsy-org/devsy/pkg/provider"
"github.com/devsy-org/devsy/pkg/secrets"
"github.com/devsy-org/devsy/pkg/workspace"
"github.com/spf13/cobra"
)

const policyBlocked clierr.Code = "dependency_policy_blocked"

type inspectOptions struct {
globalFlags *flags.GlobalFlags
forProvider string
asJSON bool
}

func newInspectCmd(globalFlags *flags.GlobalFlags) *cobra.Command {
options := &inspectOptions{globalFlags: globalFlags}
command := &cobra.Command{
Use: "inspect <tool>",
Short: "Inspect a saved provider dependency without executing it",
SilenceUsage: true,
Long: "Inspect docker, podman, apple-container, or kubernetes-config for an installed provider. " +
"Reads configuration and filesystem metadata without executing tools, contacting endpoints, or changing selection.",
Args: inspectArgs,
RunE: options.run,
}
command.Flags().
StringVar(&options.forProvider, "for-provider", "", "Inspect this installed provider without changing the default")
command.Flags().BoolVar(&options.asJSON, "json", false, "Print one dependency report as JSON")
flags.MarkPassive(command)
flags.MarkDependencyInspection(command)
command.SetFlagErrorFunc(func(_ *cobra.Command, _ error) error {
return errors.New("invalid dependency inspection flags")
})
return command
}

func inspectArgs(_ *cobra.Command, args []string) error {
if len(args) != 1 {
return errors.New("dependency inspect requires exactly one tool")
}
return nil
}

func (options *inspectOptions) run(command *cobra.Command, args []string) error {
captured := os.Environ()
cwd, err := os.Getwd()
if err != nil {
return inspectionError(command.Context(), "cannot capture dependency inspection directory")
}
request := inspectionRequest{
Tool: args[0], ForProvider: options.forProvider,
ForProviderPresent: command.Flags().Changed("for-provider"),
Environment: inspectionEnvironment(captured), WorkingDirectory: cwd,
Metadata: dependencies.PassiveReportMetadata{
EvaluatedAt: time.Now(), VirtualizationCapability: "not_required",
Redact: secrets.NewEnvironmentRedactor(captured).Redact,
},
}
mode := output.ModeJSON
if !options.asJSON {
mode, err = output.ResolveMode(options.globalFlags.ResultFormat)
if err != nil {
return errors.New("invalid dependency inspection result format")
}
}
report, err := inspectSavedProvider(command.Context(), request)
if err != nil {
return err
}
if err := command.Context().Err(); err != nil {
return err
}
if mode == output.ModeJSON {
return json.NewEncoder(command.OutOrStdout()).Encode(report)
}
_, err = fmt.Fprintf(
command.OutOrStdout(),
"%s: %s; compatibility: %s; reachability: %s\n%s\n",
report.Items[0].DisplayName,
report.Availability,
report.Compatibility,
report.Reachability,
report.Message,
)
return err
}

type inspectionRequest struct {
Tool string
ForProvider string
ForProviderPresent bool
Environment map[string]string
WorkingDirectory string
Metadata dependencies.PassiveReportMetadata
}

func inspectionError(ctx context.Context, message string) error {
if err := ctx.Err(); err != nil {
return err
}
return &clierr.CLIError{Code: policyBlocked, Message: message}
}

func inspectSavedProvider(
ctx context.Context,
request inspectionRequest,
) (dependencies.Report, error) {
if err := ctx.Err(); err != nil {
return dependencies.Report{}, err
}
prepared, err := prepareSavedInspection(ctx, request)
if err != nil {
return dependencies.Report{}, err
}
catalog, err := dependencies.LoadCatalog()
if err != nil {
return dependencies.Report{}, inspectionError(
ctx,
"cannot load the dependency inspection catalog",
)
}
if !inspectionToolMatches(catalog, prepared.Provider.Source, request.Tool) {
return dependencies.Report{}, inspectionError(
ctx,
"tool does not match the installed provider dependency",
)
}
result, err := workspace.SurveyProviderDependencies(ctx, *prepared)
if err != nil {
return dependencies.Report{}, inspectionError(
ctx,
"cannot survey the installed provider dependency",
)
}
report, err := catalog.FormatPassiveReport(result, request.Metadata)
if err != nil {
return dependencies.Report{}, inspectionError(
ctx,
"cannot format the dependency inspection report",
)
}
if err := ctx.Err(); err != nil {
return dependencies.Report{}, err
}
return report, nil
}

func prepareSavedInspection(
ctx context.Context,
request inspectionRequest,
) (*workspace.ProviderDependencySurveyRequest, error) {
inputs, err := preparedInspectionInputs(ctx)
if err != nil {
return nil, err
}
name, err := selectedProvider(
ctx,
inputs.Config,
request.ForProvider,
request.ForProviderPresent,
)
if err != nil {
return nil, err
}
installed, err := loadInspectionProvider(ctx, inputs, name)
if err != nil {
return nil, err
}
manifest, stored := installed.manifest, installed.stored
target, err := inspectionTarget(inputs.Config, name, *manifest, stored)
if err != nil {
return nil, inspectionError(ctx, "cannot fingerprint dependency inspection snapshots")
}
prepared, err := workspace.PrepareProviderDependencySurvey(
ctx,
workspace.ProviderDependencyPreparationInput{
Basis: workspace.ProviderDependencySaved,
Provider: *manifest,
StoredOptions: stored.Options,
DynamicOptions: stored.DynamicOptions,
ExplicitAssignments: map[string]string{},
Environment: request.Environment,
WorkingDirectory: request.WorkingDirectory,
Target: target,
Host: dependencies.SurveyHost{
GOOS: runtime.GOOS,
GOARCH: runtime.GOARCH,
},
},
)
if err != nil || prepared.Request == nil {
return nil, inspectionError(
ctx,
"saved provider dependency inspection is blocked by policy",
)
}
return prepared.Request, nil
}

type installedInspectionProvider struct {
manifest *provider.ProviderConfig
stored *config.ProviderConfig
}

func preparedInspectionInputs(ctx context.Context) (flags.PassiveInputs, error) {
inputs, ok := flags.PassiveInputsFromContext(ctx)
if !ok || inputs.Paths == nil || inputs.Config == nil || inputs.Config.Current() == nil {
return flags.PassiveInputs{}, inspectionError(
ctx,
"dependency inspection requires prepared passive inputs",
)
}
return inputs, nil
}

func loadInspectionProvider(
ctx context.Context,
inputs flags.PassiveInputs,
name string,
) (installedInspectionProvider, error) {
stored := inputs.Config.Current().Providers[name]
if stored == nil {
return installedInspectionProvider{}, inspectionError(
ctx,
"dependency inspection requires an installed provider record",
)
}
manifest, err := provider.LoadProviderConfigWithPathManager(
inputs.Paths,
inputs.Config.DefaultContext,
name,
)
if err != nil || manifest == nil || manifest.Name != name {
return installedInspectionProvider{}, inspectionError(
ctx,
"cannot load the installed dependency inspection provider",
)
}
if err := ctx.Err(); err != nil {
return installedInspectionProvider{}, err
}
return installedInspectionProvider{manifest: manifest, stored: stored}, nil
}

func selectedProvider(
ctx context.Context,
snapshot *config.Config,
override string,
present bool,
) (string, error) {
name := snapshot.Current().DefaultProvider
if present {
if override == "" {
return "", errors.New("dependency inspect requires a nonempty --for-provider")
}
name = override
}
invocation := flags.InspectionInvocationFromContext(ctx)
if invocation.ProviderPresent && invocation.Provider != name {
return "", errors.New("--provider conflicts with the dependency inspection target")
}
if name == "" {
return "", inspectionError(
ctx,
"dependency inspection requires an installed provider selection",
)
}
return name, nil
}

func inspectionTarget(
snapshot *config.Config,
name string,
manifest provider.ProviderConfig,
stored *config.ProviderConfig,
) (dependencies.SurveyTarget, error) {
configRevision, err := snapshotRevision(snapshot)
if err != nil {
return dependencies.SurveyTarget{}, err
}
providerRevision, err := snapshotRevision(providerSnapshotV1{
Version: 1,
Manifest: manifest,
StoredOptions: stored.Options,
DynamicOptions: stored.DynamicOptions,
})
return dependencies.SurveyTarget{
ContextName: snapshot.DefaultContext, ProviderName: name,
ConfigRevision: configRevision, ProviderConfigRevision: providerRevision,
}, err
}

// Preparation already verified the complete internal manifest. Match its source
// against the catalog before any executable filesystem lookup can occur.
func inspectionToolMatches(
catalog *dependencies.Catalog,
source provider.ProviderSource,
tool string,
) bool {
if !source.Internal {
return false
}
for _, binding := range catalog.Bindings() {
if binding.Source.Kind == dependencies.SourceInternal &&
binding.Source.InternalID == source.Raw {
return len(binding.Requirements) == 1 && binding.Requirements[0].ToolID == tool
}
}
return false
}
Loading
Loading