Skip to content

ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.

feat(manifest): fromSecret/fromService/generate reference binders (Phase 3)

Juan Denisf823c6c74ff3
diff --git a/backend/app/models/env_variable.py b/backend/app/models/env_variable.py
index b472c617..3bacdc10 100644
--- a/backend/app/models/env_variable.py
+++ b/backend/app/models/env_variable.py
@@ -22,6 +22,12 @@ class EnvironmentVariable(db.Model):
# Compose service this var targets (NULL = all services). Lets a compose app
# scope a variable to one service in the managed env overlay.
target_service = db.Column(db.String(120), nullable=True)
+ # Reference source (manifest fromSecret/fromService/generate). When set, the
+ # real value is resolved at injection time and never stored in
+ # encrypted_value — masking stays intact and a rotated secret propagates on
+ # the next deploy/restart. JSON e.g. {"kind":"secret","secret":"stripe"} or
+ # {"kind":"service","service":"db","property":"connectionString"}.
+ value_from = db.Column(db.Text, nullable=True)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
@@ -75,8 +81,23 @@ class EnvironmentVariable(db.Model):
"""Set the value (encrypts automatically)."""
self.encrypted_value = self.encrypt_value(plaintext)
+ def get_reference(self):
+ """Parsed value_from reference, or None for a plain value."""
+ if not self.value_from:
+ return None
+ import json
+ try:
+ return json.loads(self.value_from)
+ except Exception:
+ return None
+
+ def set_reference(self, ref):
+ import json
+ self.value_from = json.dumps(ref) if ref else None
+
def to_dict(self, include_value=True, mask_secrets=False):
"""Convert to dictionary, optionally masking secret values."""
+ reference = self.get_reference()
result = {
'id': self.id,
'application_id': self.application_id,
@@ -84,12 +105,17 @@ class EnvironmentVariable(db.Model):
'is_secret': self.is_secret,
'description': self.description,
'target_service': self.target_service,
+ 'is_reference': bool(reference),
+ 'value_from': reference,
'created_at': self.created_at.isoformat() if self.created_at else None,
'updated_at': self.updated_at.isoformat() if self.updated_at else None,
}
if include_value:
- if mask_secrets and self.is_secret:
+ if reference:
+ # a reference's real value is never serialized here
+ result['value'] = '••••••••' if mask_secrets else ''
+ elif mask_secrets and self.is_secret:
result['value'] = '••••••••'
else:
result['value'] = self.value
diff --git a/backend/app/services/env_reference_service.py b/backend/app/services/env_reference_service.py
new file mode 100644
index 00000000..f1604cc0
--- /dev/null
+++ b/backend/app/services/env_reference_service.py
@@ -0,0 +1,122 @@
+"""Resolve manifest env references at injection time (plan 17, Phase 3).
+
+`fromSecret` -> a vault secret's value; `fromService` -> a sibling service's
+connection property. The resolved value never lands in the env-var row — it is
+computed here whenever the effective env is built, so rotating a vault secret or
+changing a db password propagates on the next deploy/restart.
+"""
+
+import logging
+from typing import Any, Dict, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+# fromService properties by kind
+_DB_PROPERTIES = ('connectionString', 'host', 'port', 'database', 'username', 'password')
+_APP_PROPERTIES = ('host', 'port', 'url')
+
+
+class EnvReferenceResolver:
+
+ @classmethod
+ def resolve(cls, app, ref: Dict[str, Any]) -> Tuple[Optional[str], Optional[str]]:
+ """Resolve a reference for ``app``. Returns (value, error)."""
+ if not isinstance(ref, dict):
+ return None, 'invalid reference'
+ kind = ref.get('kind')
+ if kind == 'secret':
+ return cls._resolve_secret(ref.get('secret'))
+ if kind == 'service':
+ return cls._resolve_service(app, ref.get('service'), ref.get('property'))
+ return None, f'unknown reference kind: {kind}'
+
+ # -- fromSecret ---------------------------------------------------------
+
+ @classmethod
+ def _resolve_secret(cls, name: Optional[str]) -> Tuple[Optional[str], Optional[str]]:
+ if not name:
+ return None, 'missing secret name'
+ from app.models.secret_vault import Secret
+ # a bare name resolves against any vault; a "vault/name" form scopes it
+ vault_slug = None
+ secret_name = name
+ if '/' in name:
+ vault_slug, secret_name = name.split('/', 1)
+ q = Secret.query.filter_by(name=secret_name)
+ if vault_slug:
+ from app.models.secret_vault import SecretVault
+ vault = SecretVault.query.filter_by(slug=vault_slug).first()
+ if not vault:
+ return None, f'vault `{vault_slug}` not found'
+ q = q.filter_by(vault_id=vault.id)
+ secret = q.order_by(Secret.id).first()
+ if not secret:
+ return None, f'secret `{name}` not found'
+ try:
+ return secret.value, None
+ except Exception as exc: # decryption failure
+ return None, f'secret `{name}` unreadable: {exc}'
+
+ @classmethod
+ def secret_exists(cls, name: Optional[str]) -> bool:
+ value, error = cls._resolve_secret(name)
+ return error is None
+
+ # -- fromService --------------------------------------------------------
+
+ @classmethod
+ def _resolve_service(cls, app, service_name: Optional[str],
+ prop: Optional[str]) -> Tuple[Optional[str], Optional[str]]:
+ if not service_name or not prop:
+ return None, 'missing service/property'
+ project_id = getattr(app, 'project_id', None)
+
+ # db sibling first (ManagedDatabase by name within the workspace)
+ from app.models.managed_database import ManagedDatabase
+ managed = ManagedDatabase.query.filter_by(name=service_name).first()
+ if managed is not None:
+ return cls._db_property(managed, prop)
+
+ # app sibling (Application by name within the project)
+ from app.models.application import Application
+ sibling = None
+ if project_id is not None:
+ sibling = Application.query.filter_by(project_id=project_id, name=service_name).first()
+ if sibling is None:
+ sibling = Application.query.filter_by(name=service_name).first()
+ if sibling is not None:
+ return cls._app_property(sibling, service_name, prop)
+
+ return None, f'service `{service_name}` not found'
+
+ @classmethod
+ def _db_property(cls, managed, prop: str) -> Tuple[Optional[str], Optional[str]]:
+ from app.services.managed_database_service import ManagedDatabaseService
+ if prop == 'connectionString':
+ return ManagedDatabaseService.build_connection_uri(managed, reveal=True), None
+ if prop == 'host':
+ return managed.host, None
+ if prop == 'port':
+ return str(managed.effective_port()), None
+ if prop == 'database':
+ return managed.name, None
+ if prop == 'username':
+ return managed.admin_username or '', None
+ if prop == 'password':
+ from app.utils.crypto import decrypt_secret_safe
+ return (decrypt_secret_safe(managed.admin_secret_encrypted) or '') \
+ if managed.admin_secret_encrypted else '', None
+ return None, f'property `{prop}` not valid for a database service'
+
+ @classmethod
+ def _app_property(cls, sibling, service_name: str, prop: str) -> Tuple[Optional[str], Optional[str]]:
+ # in-cluster addressing: the service name resolves on the compose/docker network
+ host = service_name
+ port = sibling.port
+ if prop == 'host':
+ return host, None
+ if prop == 'port':
+ return str(port) if port else '', None
+ if prop == 'url':
+ return f'http://{host}:{port}' if port else f'http://{host}', None
+ return None, f'property `{prop}` not valid for an app service'
diff --git a/backend/app/services/env_service.py b/backend/app/services/env_service.py
index 31e61a85..cd06f8d5 100644
--- a/backend/app/services/env_service.py
+++ b/backend/app/services/env_service.py
@@ -90,10 +90,66 @@ class EnvService:
# 2) Local env vars — the override layer (highest precedence wins).
for ev in EnvironmentVariable.query.filter_by(application_id=application_id).all():
- merged[ev.key] = ev.value # decrypted via the model's `value` property
+ merged[ev.key] = EnvService._resolve_var_value(app, ev)
return merged
+ @staticmethod
+ def _resolve_var_value(app, ev):
+ """Decrypt a plain value, or resolve a manifest reference at injection."""
+ if not ev.value_from:
+ return ev.value
+ try:
+ from app.services.env_reference_service import EnvReferenceResolver
+ value, error = EnvReferenceResolver.resolve(app, ev.get_reference())
+ if error:
+ logger.warning('Env reference %s on app %s unresolved: %s',
+ ev.key, ev.application_id, error)
+ return ''
+ return value
+ except Exception as exc: # best-effort — never block a deploy
+ logger.warning('Env reference %s resolution failed: %s', ev.key, exc)
+ return ''
+
+ @staticmethod
+ def set_env_reference(application_id, key, reference, user_id=None, target_service=_UNSET):
+ """Create/update a variable that resolves from a reference (manifest).
+
+ ``reference`` is a dict e.g. {'kind':'secret','secret':'name'} or
+ {'kind':'service','service':'db','property':'connectionString'}. The real
+ value is never stored — encrypted_value holds a placeholder.
+ """
+ valid, error = EnvService.validate_key(key)
+ if not valid:
+ return None, False, error
+ app = Application.query.get(application_id)
+ if not app:
+ return None, False, 'Application not found'
+
+ norm_target = None if target_service in ('', _UNSET) else target_service
+ existing = EnvService.get_env_var(application_id, key)
+ if existing:
+ existing.set_reference(reference)
+ existing.is_secret = True
+ existing.value = '' # clear any stored literal
+ if target_service is not _UNSET:
+ existing.target_service = norm_target
+ db.session.commit()
+ return existing, False, None
+
+ env_var = EnvironmentVariable(
+ application_id=application_id, key=key, is_secret=True,
+ target_service=norm_target, created_by=user_id,
+ )
+ env_var.set_reference(reference)
+ env_var.value = ''
+ db.session.add(env_var)
+ db.session.flush()
+ EnvironmentVariableHistory.record_change(env_var, 'created', new_value='<reference>',
+ user_id=user_id)
+ db.session.commit()
+ return env_var, True, None
+
@staticmethod
def get_effective_env_for_services(application_id, service_names):
"""Per-service effective env for a compose app.
@@ -139,7 +195,7 @@ class EnvService:
for ev in local_vars:
tgt = ev.target_service
if tgt in (None, '') or tgt == svc:
- env[ev.key] = ev.value
+ env[ev.key] = EnvService._resolve_var_value(app, ev)
result[svc] = env
return result
diff --git a/backend/app/services/manifest_apply_service.py b/backend/app/services/manifest_apply_service.py
index 34d2a0f1..4e77f52d 100644
--- a/backend/app/services/manifest_apply_service.py
+++ b/backend/app/services/manifest_apply_service.py
@@ -42,6 +42,7 @@ _STEP_ORDER = {
'create_app': 2,
'update_app': 3,
'set_env': 4,
+ 'set_env_ref': 4,
'ensure_volume': 5,
'upsert_backup_policy': 6,
'attach_domain': 7,
@@ -90,6 +91,7 @@ class ManifestApplyService:
"""Diff desired manifest vs live state -> ordered action plan."""
env = environment or cls._default_environment(project)
steps: List[Dict[str, Any]] = []
+ issues: List[Dict[str, Any]] = []
services = normalized.get('services', [])
for svc in services:
@@ -97,7 +99,7 @@ class ManifestApplyService:
if resolved['kind'] == 'database':
steps.extend(cls._plan_db(resolved))
else:
- steps.extend(cls._plan_app(project, env, resolved))
+ steps.extend(cls._plan_app(project, env, resolved, issues))
steps.extend(cls._plan_domains(project, normalized.get('domains', [])))
@@ -107,6 +109,7 @@ class ManifestApplyService:
'environment_id': env.id if env else None,
'steps': steps,
'step_count': len(steps),
+ 'issues': issues,
'summary': cls._summarize_plan(steps),
}
@@ -140,8 +143,10 @@ class ManifestApplyService:
@classmethod
def _plan_app(cls, project: Project, env: Optional[Environment],
- resolved: Dict[str, Any]) -> List[Dict[str, Any]]:
+ resolved: Dict[str, Any],
+ issues: Optional[List[Dict[str, Any]]] = None) -> List[Dict[str, Any]]:
steps: List[Dict[str, Any]] = []
+ issues = issues if issues is not None else []
name = resolved['name']
app = cls._find_app(project, name)
@@ -178,6 +183,31 @@ class ManifestApplyService:
'payload': {'app_id': app.id if app else None, 'env': to_set},
})
+ # env references (fromSecret / fromService / generate) — Phase 3
+ live_vars = cls._live_env_vars(app) if app else {}
+ for ref in resolved.get('env_refs', []):
+ key = ref['key']
+ source = ref['source']
+ if source == 'generate':
+ desired = {'kind': 'secret', 'secret': cls._generated_secret_name(name, key)}
+ live = live_vars.get(key)
+ # a generated secret is created once; leave it in place afterwards
+ if live is not None and (live.get_reference() or {}).get('kind') == 'secret':
+ continue
+ steps.append(cls._set_env_ref_step(name, app, key, desired, generate=True))
+ elif source == 'secret':
+ desired = {'kind': 'secret', 'secret': ref['secret_name']}
+ if not cls._secret_exists(ref['secret_name']):
+ issues.append({'service': name, 'key': key, 'kind': 'missing_secret',
+ 'secret': ref['secret_name']})
+ if cls._ref_changed(live_vars.get(key), desired):
+ steps.append(cls._set_env_ref_step(name, app, key, desired))
+ elif source == 'service':
+ sr = ref['service_ref']
+ desired = {'kind': 'service', 'service': sr['name'], 'property': sr['property']}
+ if cls._ref_changed(live_vars.get(key), desired):
+ steps.append(cls._set_env_ref_step(name, app, key, desired))
+
# disks
for disk in resolved.get('disks', []):
mount = disk.get('mount_path')
@@ -283,6 +313,7 @@ class ManifestApplyService:
'success': not failed,
'job_id': job.id,
'applied': sum(1 for r in results if r['status'] == 'ok'),
+ 'issues': plan.get('issues', []),
'results': results,
'plan': plan,
}
@@ -380,6 +411,20 @@ class ManifestApplyService:
raise RuntimeError('; '.join(errors))
return {'set': count}
+ @classmethod
+ def _do_set_env_ref(cls, project, env, payload, user_id):
+ from app.services.env_service import EnvService
+ app_id = payload.get('app_id') or cls._resolve_app_id(project, payload)
+ ref = payload['ref']
+ if payload.get('generate'):
+ secret_name = ref['secret']
+ cls._ensure_generated_secret(secret_name)
+ ref = {'kind': 'secret', 'secret': secret_name}
+ _var, _created, err = EnvService.set_env_reference(app_id, payload['key'], ref, user_id)
+ if err:
+ raise RuntimeError(err)
+ return {'key': payload['key'], 'ref': ref}
+
@classmethod
def _do_ensure_volume(cls, project, env, payload, user_id):
from app.services.volume_service import VolumeService
@@ -518,6 +563,61 @@ class ManifestApplyService:
want_cron = _SCHEDULE_CRON.get(backup['schedule'], '0 2 * * *')
return pol.schedule_cron == want_cron and pol.retention_count == backup['retain']
+ @classmethod
+ def _set_env_ref_step(cls, name, app, key, ref, generate=False):
+ verb = 'Generate secret for' if generate else 'Bind reference'
+ return {
+ 'type': 'set_env_ref', 'service': name,
+ 'description': f'{verb} `{key}` on `{name}`',
+ 'payload': {'app_id': app.id if app else None, 'key': key,
+ 'ref': ref, 'generate': generate},
+ }
+
+ @staticmethod
+ def _live_env_vars(app: Application) -> Dict[str, Any]:
+ from app.models.env_variable import EnvironmentVariable
+ return {ev.key: ev for ev in
+ EnvironmentVariable.query.filter_by(application_id=app.id).all()}
+
+ @staticmethod
+ def _ref_changed(live_var, desired: Dict[str, Any]) -> bool:
+ if live_var is None:
+ return True
+ current = live_var.get_reference()
+ return current != desired
+
+ @staticmethod
+ def _secret_exists(name: str) -> bool:
+ from app.services.env_reference_service import EnvReferenceResolver
+ return EnvReferenceResolver.secret_exists(name)
+
+ @staticmethod
+ def _generated_secret_name(service: str, key: str) -> str:
+ import re
+ return re.sub(r'[^a-z0-9]+', '_', f'{service}_{key}'.lower()).strip('_')
+
+ @staticmethod
+ def _ensure_generated_secret(secret_name: str):
+ """Get-or-create a random vault secret in the `manifest` vault."""
+ import secrets as _secrets
+ from app.models.secret_vault import SecretVault, Secret
+ from app.utils.crypto import encrypt_secret
+ existing = Secret.query.filter_by(name=secret_name).first()
+ if existing:
+ return existing
+ vault = SecretVault.query.filter_by(slug='manifest').first()
+ if not vault:
+ vault = SecretVault(name='Manifest', slug='manifest',
+ description='Auto-generated manifest secrets')
+ db.session.add(vault)
+ db.session.flush()
+ secret = Secret(vault_id=vault.id, name=secret_name,
+ encrypted_value=encrypt_secret(_secrets.token_urlsafe(32)),
+ description='Generated by a serverkit.yaml manifest')
+ db.session.add(secret)
+ db.session.flush()
+ return secret
+
@staticmethod
def _find_app(project: Project, name: Optional[str]) -> Optional[Application]:
if not name:
diff --git a/backend/migrations/versions/055_manifest_env_refs.py b/backend/migrations/versions/055_manifest_env_refs.py
new file mode 100644
index 00000000..41754744
--- /dev/null
+++ b/backend/migrations/versions/055_manifest_env_refs.py
@@ -0,0 +1,44 @@
+"""Manifest env references — value_from (plan 17, Phase 3).
+
+Adds:
+- environment_variables.value_from (Text, nullable) — a fromSecret/fromService/
+ generate reference resolved at injection time (the value never lands in the
+ row, so masking stays intact and a rotated secret propagates on next deploy).
+
+Idempotent: MigrationService runs _fix_missing_columns() + db.create_all() on boot
+before Alembic, so guard on the live schema.
+
+Revision ID: 055_manifest_env_refs
+Revises: 054_serverkit_manifest
+Create Date: 2026-07-04
+"""
+from alembic import op
+import sqlalchemy as sa
+
+revision = '055_manifest_env_refs'
+down_revision = '054_serverkit_manifest'
+branch_labels = None
+depends_on = None
+
+_TABLE = 'environment_variables'
+_COLUMN = 'value_from'
+
+
+def upgrade():
+ conn = op.get_bind()
+ inspector = sa.inspect(conn)
+ if _TABLE not in set(inspector.get_table_names()):
+ return
+ cols = {c['name'] for c in inspector.get_columns(_TABLE)}
+ if _COLUMN not in cols:
+ op.add_column(_TABLE, sa.Column(_COLUMN, sa.Text(), nullable=True))
+
+
+def downgrade():
+ conn = op.get_bind()
+ inspector = sa.inspect(conn)
+ if _TABLE not in set(inspector.get_table_names()):
+ return
+ cols = {c['name'] for c in inspector.get_columns(_TABLE)}
+ if _COLUMN in cols:
+ op.drop_column(_TABLE, _COLUMN)
diff --git a/backend/tests/test_manifest_apply.py b/backend/tests/test_manifest_apply.py
index 955ca2d1..864c8ed1 100644
--- a/backend/tests/test_manifest_apply.py
+++ b/backend/tests/test_manifest_apply.py
@@ -101,11 +101,12 @@ def test_apply_materializes_and_is_idempotent(project, owner):
assert api.healthcheck_path == '/health'
assert api.source == 'manifest'
- # env literal set, secret ref NOT applied in Phase 2
+ # env literal set; secret ref is BOUND (Phase 3) but resolves empty because
+ # the referenced vault secret does not exist here
from app.services.env_service import EnvService
- env = EnvService.get_env_dict(api.id)
+ env = EnvService.get_effective_env(api.id)
assert env.get('LOG_LEVEL') == 'info'
- assert 'SECRET_TOKEN' not in env
+ assert env.get('SECRET_TOKEN') == ''
# managed db recorded
mdb = ManagedDatabase.query.filter_by(engine='postgresql', name='db').first()
diff --git a/backend/tests/test_manifest_references.py b/backend/tests/test_manifest_references.py
new file mode 100644
index 00000000..698b3436
--- /dev/null
+++ b/backend/tests/test_manifest_references.py
@@ -0,0 +1,146 @@
+"""Proving tests for Phase 3 — reference binders (plan 17)."""
+
+import pytest
+
+import app.models.application_manifest # noqa: F401
+from app.services.manifest_spec_service import ManifestSpecService
+from app.services.manifest_apply_service import ManifestApplyService
+from app.services.env_service import EnvService
+from app.services.env_reference_service import EnvReferenceResolver
+
+
+def owner(app):
+ from app import db
+ from app.models import User
+ user = User.query.filter_by(username='testadmin').first()
+ if not user:
+ user = User(username='testadmin', email='[email protected]', role='admin')
+ db.session.add(user)
+ db.session.commit()
+ return user
+
+
+def project(app):
+ from app import db
+ from app.models import Project, Environment
+ from app.services.workspace_service import WorkspaceService
+ ws = WorkspaceService.ensure_default_workspace()
+ proj = Project(workspace_id=ws.id, name='Ref', slug='ref')
+ db.session.add(proj)
+ db.session.commit()
+ env = Environment(project_id=proj.id, name='Prod', slug='prod', is_default=True)
+ db.session.add(env)
+ db.session.commit()
+ return proj
+
+
+def _app_in(project, owner, name='api', port=8000):
+ from app import db
+ from app.models import Application
+ a = Application(name=name, app_type='docker', port=port, user_id=owner.id,
+ project_id=project.id, status='running')
+ db.session.add(a)
+ db.session.commit()
+ return a
+
+
+def _secret(name, value):
+ from app import db
+ from app.models.secret_vault import SecretVault, Secret
+ from app.utils.crypto import encrypt_secret
+ vault = SecretVault.query.filter_by(slug='v').first()
+ if not vault:
+ vault = SecretVault(name='V', slug='v')
+ db.session.add(vault)
+ db.session.flush()
+ s = Secret(vault_id=vault.id, name=name, encrypted_value=encrypt_secret(value))
+ db.session.add(s)
+ db.session.commit()
+ return s
+
+
+def test_from_secret_resolved_and_masked(project, owner):
+ _secret('stripe_prod', 'sk_live_123')
+ a = _app_in(project, owner)
+ EnvService.set_env_reference(a.id, 'STRIPE_KEY', {'kind': 'secret', 'secret': 'stripe_prod'},
+ owner.id)
+ # resolved at injection time
+ env = EnvService.get_effective_env(a.id)
+ assert env['STRIPE_KEY'] == 'sk_live_123'
+ # masked + never serialized in the row
+ rows = {r['key']: r for r in EnvService.get_env_vars(a.id, mask_secrets=True)}
+ assert rows['STRIPE_KEY']['value'] == '••••••••'
+ assert rows['STRIPE_KEY']['is_reference'] is True
+ # even unmasked, the reference value is not stored in the row
+ rows_unmasked = {r['key']: r for r in EnvService.get_env_vars(a.id)}
+ assert rows_unmasked['STRIPE_KEY']['value'] == ''
+
+
+def test_from_service_db_connection_string(project, owner):
+ from app.services.managed_database_service import ManagedDatabaseService
+ ManagedDatabaseService.record_provisioned(engine='postgresql', name='db',
+ workspace_id=project.workspace_id)
+ a = _app_in(project, owner)
+ EnvService.set_env_reference(a.id, 'DATABASE_URL',
+ {'kind': 'service', 'service': 'db', 'property': 'connectionString'},
+ owner.id)
+ env = EnvService.get_effective_env(a.id)
+ assert env['DATABASE_URL'].startswith('postgresql://')
+ assert 'db' in env['DATABASE_URL']
+
+
+def test_from_service_app_url(project, owner):
+ _app_in(project, owner, name='web', port=3000)
+ a = _app_in(project, owner, name='worker')
+ EnvService.set_env_reference(a.id, 'WEB_URL',
+ {'kind': 'service', 'service': 'web', 'property': 'url'}, owner.id)
+ env = EnvService.get_effective_env(a.id)
+ assert env['WEB_URL'] == 'http://web:3000'
+
+
+def test_missing_secret_is_plan_time_issue(project, owner):
+ manifest = {'version': 1, 'services': [{
+ 'name': 'api', 'type': 'web',
+ 'envVars': [{'key': 'MISSING', 'fromSecret': 'nope'}]}]}
+ n = ManifestSpecService.normalize(manifest)
+ plan = ManifestApplyService.plan(project, n)
+ assert any(i['kind'] == 'missing_secret' and i['secret'] == 'nope' for i in plan['issues'])
+
+
+def test_generate_creates_secret_and_is_idempotent(project, owner):
+ from app.models.secret_vault import Secret
+ manifest = {'version': 1, 'services': [{
+ 'name': 'api', 'type': 'web',
+ 'envVars': [{'key': 'SESSION_SECRET', 'generate': True}]}]}
+ n = ManifestSpecService.normalize(manifest)
+
+ result = ManifestApplyService.apply(project, n, user_id=owner.id)
+ assert result['success'] is True
+
+ from app.models import Application
+ a = Application.query.filter_by(project_id=project.id, name='api').first()
+ # a vault secret was generated and the env var references it
+ env = EnvService.get_effective_env(a.id)
+ assert env['SESSION_SECRET'] # non-empty generated value
+ gen_secret = Secret.query.filter_by(name='api_session_secret').first()
+ assert gen_secret is not None
+
+ # idempotent — second plan does not regenerate
+ plan2 = ManifestApplyService.plan(project, n)
+ assert not any(s['type'] == 'set_env_ref' for s in plan2['steps'])
+
+
+def test_apply_binds_from_secret_end_to_end(project, owner):
+ _secret('api_token', 'tok-xyz')
+ manifest = {'version': 1, 'services': [{
+ 'name': 'api', 'type': 'web',
+ 'envVars': [{'key': 'API_TOKEN', 'fromSecret': 'api_token'}]}]}
+ n = ManifestSpecService.normalize(manifest)
+ result = ManifestApplyService.apply(project, n, user_id=owner.id)
+ assert result['success'] is True
+ assert result['issues'] == []
+ from app.models import Application
+ a = Application.query.filter_by(project_id=project.id, name='api').first()
+ assert EnvService.get_effective_env(a.id)['API_TOKEN'] == 'tok-xyz'