Migrate dagger.#Secret and dagger.#Stream to new format

- Refactored to keep every transformation of built-in types (e.g. FS,
  Secret, etc) to/from CUE in the same place (plancontext)
- dagger.#Service and dagger.#Secret are now following the new FS-like format
  (e.g. `_service: id: string`)
- Backward compatibility
- dagger.#Stream is now an alias for dagger.#Service

Signed-off-by: Andrea Luzzardi <aluzzardi@gmail.com>

plancontext/secret.go

@@ -1,26 +1,77 @@
 package plancontext
 
-import "sync"
+import (
+	"fmt"
+	"sync"
+
+	"cuelang.org/go/cue"
+	"go.dagger.io/dagger/compiler"
+)
+
+var (
+	secretIDPath = cue.MakePath(
+		cue.Hid("_secret", "alpha.dagger.io/dagger"),
+		cue.Str("id"),
+	)
+)
+
+type Secret struct {
+	id        string
+	plainText string
+}
+
+func (s *Secret) ID() string {
+	return s.id
+}
+
+func (s *Secret) PlainText() string {
+	return s.plainText
+}
+
+func (s *Secret) Value() *compiler.Value {
+	v := compiler.NewValue()
+	if err := v.FillPath(secretIDPath, s.id); err != nil {
+		panic(err)
+	}
+	return v
+}
 
 type secretContext struct {
 	l     sync.RWMutex
-	store map[ContextKey]*Secret
+	store map[string]*Secret
 }
 
-type Secret struct {
-	PlainText string
-}
+func (c *secretContext) New(plaintext string) *Secret {
+	secret := &Secret{
+		id:        hashID(plaintext),
+		plainText: plaintext,
+	}
 
-func (c *secretContext) Register(secret *Secret) ContextKey {
 	c.l.Lock()
 	defer c.l.Unlock()
 
-	id := hashID(secret.PlainText)
-	c.store[id] = secret
-	return id
+	c.store[secret.id] = secret
+	return secret
 }
 
-func (c *secretContext) Get(id ContextKey) *Secret {
+func (c *secretContext) FromValue(v *compiler.Value) (*Secret, error) {
+	c.l.RLock()
+	defer c.l.RUnlock()
+
+	id, err := v.LookupPath(secretIDPath).String()
+	if err != nil {
+		return nil, fmt.Errorf("invalid secret %q: %w", v.Path(), err)
+	}
+
+	secret, ok := c.store[id]
+	if !ok {
+		return nil, fmt.Errorf("secret %q not found", id)
+	}
+
+	return secret, nil
+}
+
+func (c *secretContext) Get(id string) *Secret {
 	c.l.RLock()
 	defer c.l.RUnlock()