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.
Python astracloudflarecontrol-panelcyberpaneldnsfablehosting-control-panelhosting-panelkimi-k3server-managementserverkitubuntu-web-panelwebserver
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.pyindex 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.valuediff --git a/backend/app/services/env_reference_service.py b/backend/app/services/env_reference_service.pynew file mode 100644index 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.pyindex 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+@staticmethoddef 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_serviceif tgt in (None, '') or tgt == svc:- env[ev.key] = ev.value+ env[ev.key] = EnvService._resolve_var_value(app, ev)result[svc] = envreturn resultdiff --git a/backend/app/services/manifest_apply_service.py b/backend/app/services/manifest_apply_service.pyindex 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:@classmethoddef _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))+# disksfor 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}+@classmethoddef _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+@staticmethoddef _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.pynew file mode 100644index 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.pyindex 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 herefrom 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 recordedmdb = ManagedDatabase.query.filter_by(engine='postgresql', name='db').first()diff --git a/backend/tests/test_manifest_references.py b/backend/tests/test_manifest_references.pynew file mode 100644index 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'