Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.
Go agentagenticaichatbotdsh-pluginembeddingsevaluationgenerative-aigolangknowledge-basellmmulti-tenantollamaopenaiquestion-answeringragrerankingsemantic-searchvector-searchwiki
fix(sandbox): make skill env capture fill blanks only
wizardchene13eaca7e4d9
diff --git a/frontend/src/components/SandboxConfigEditorDrawer.vue b/frontend/src/components/SandboxConfigEditorDrawer.vueindex 35d1833ea..97b7ce141 100644--- a/frontend/src/components/SandboxConfigEditorDrawer.vue+++ b/frontend/src/components/SandboxConfigEditorDrawer.vue@@ -472,6 +472,9 @@<p v-if="pendingCheckNames.length" class="check-result__hint">{{ $t('settings.sandbox.checkPendingHint', { names: pendingCheckNames.join('、') }) }}</p>+ <t-alert v-if="checkResult.capabilities && checkResult.capabilities.supports_volumes === false" theme="warning"+ class="compact-alert"+ :message="$t('settings.sandbox.noVolumeSupport')" /></div></SettingDrawer>diff --git a/internal/agent/skills/env_resolver.go b/internal/agent/skills/env_resolver.goindex 890447871..5418dfe38 100644--- a/internal/agent/skills/env_resolver.go+++ b/internal/agent/skills/env_resolver.go@@ -34,11 +34,16 @@ type MissingSkillEnvError struct {func (e *MissingSkillEnvError) Error() string {// English, like every other error in this codebase: the agent relays this// to the user and translates it into whatever language they are speaking.+ // execute_skill_script has no env parameter, so it cannot take a value the+ // user just typed. shell_exec can: naming the skill and passing the value+ // in env runs the command and stores the value for the next run. Pointing+ // at the settings page alone would strand IM users, who have no such page.return fmt.Sprintf("skill %q needs the environment variable(s) %s, which nobody has set yet. "+- "Set them under Settings → Environment variables and try again, "+- "or just tell me the env directly.",- e.SkillName, strings.Join(e.Names, ", "),+ "Ask the user for them, then run the skill through shell_exec with "++ "skill_name=%q and the values in env — they are stored for that user "++ "afterwards. They can also be set under Settings → Environment variables.",+ e.SkillName, strings.Join(e.Names, ", "), e.SkillName,)}diff --git a/internal/agent/tools/shell_env_extract.go b/internal/agent/tools/shell_env_extract.goindex a10e34597..4ca3171e4 100644--- a/internal/agent/tools/shell_env_extract.go+++ b/internal/agent/tools/shell_env_extract.go@@ -3,9 +3,6 @@ package toolsimport ("regexp""strings"- "unicode"-- "github.com/Tencent/WeKnora/internal/sandbox")// assignmentPattern finds NAME=value in a model-built shell command.@@ -39,37 +36,16 @@ func collectUsedSkillEnv(command string, toolEnv map[string]string) map[string]sreturn out}-func inferSkillName(explicit, command string) string {- if sandbox.IsValidSkillName(strings.TrimSpace(explicit)) {- return strings.TrimSpace(explicit)- }- prefix := sandbox.SkillsImageRoot + "/"- from := 0- for {- idx := strings.Index(command[from:], prefix)- if idx < 0 {- return ""- }- idx += from- name, ok := firstPathSegment(command[idx+len(prefix):])- if ok && sandbox.IsValidSkillName(name) {- return name+// maskCommandAssignments replaces the value of every NAME=value assignment with+// a placeholder. A command is logged at Info, and passing a credential inline is+// a documented way to hand a skill its key, so the raw string must never reach+// the log.+func maskCommandAssignments(command string) string {+ return assignmentPattern.ReplaceAllStringFunc(command, func(match string) string {+ eq := strings.Index(match, "=")+ if eq < 0 {+ return match}- from = idx + len(prefix)- }-}--func firstPathSegment(rest string) (string, bool) {- end := 0- for end < len(rest) {- r := rune(rest[end])- if r == '/' || unicode.IsSpace(r) || r == '"' || r == '\'' || r == ';' || r == '&' || r == '|' {- break- }- end++- }- if end == 0 {- return "", false- }- return rest[:end], true+ return match[:eq+1] + "***"+ })}diff --git a/internal/agent/tools/shell_env_extract_test.go b/internal/agent/tools/shell_env_extract_test.goindex cdb3111bd..aae72e5b7 100644--- a/internal/agent/tools/shell_env_extract_test.go+++ b/internal/agent/tools/shell_env_extract_test.go@@ -44,24 +44,15 @@ func TestCollectUsedSkillEnvOverlaysToolEnvOnExports(t *testing.T) {assert.Equal(t, "e", got["EXTRA"])}-func TestInferSkillNamePrefersExplicitToolField(t *testing.T) {- command := `cd /opt/weknora/tenant/skills/other-skill && python x.py`+func TestMaskCommandAssignmentsHidesValues(t *testing.T) {+ command := `export BIGMODEL_API_KEY="sk-abc.def"; TOKEN=plain ./run --model cogview-4`- assert.Equal(t, "pdf-tools", inferSkillName("pdf-tools", command))-}--func TestInferSkillNameFromCdIntoSkillsRoot(t *testing.T) {- command := `cd /opt/weknora/tenant/skills/bigmodel-image-video && .venv/bin/python scripts/generate.py "草原"`-- assert.Equal(t, "bigmodel-image-video", inferSkillName("", command))-}--func TestInferSkillNameFromScriptPath(t *testing.T) {- command := `/opt/weknora/tenant/skills/bigmodel-image-video/.venv/bin/python /opt/weknora/tenant/skills/bigmodel-image-video/scripts/generate.py`-- assert.Equal(t, "bigmodel-image-video", inferSkillName("", command))-}+ got := maskCommandAssignments(command)-func TestInferSkillNameEmptyWhenCommandDoesNotTouchSkillsRoot(t *testing.T) {- assert.Empty(t, inferSkillName("", "ls /workspace"))+ assert.NotContains(t, got, "sk-abc.def")+ assert.NotContains(t, got, "plain")+ assert.Contains(t, got, "BIGMODEL_API_KEY=***")+ assert.Contains(t, got, "TOKEN=***")+ // Ordinary flags stay readable: a masked log still has to be a usable one.+ assert.Contains(t, got, "--model cogview-4")}diff --git a/internal/agent/tools/shell_exec.go b/internal/agent/tools/shell_exec.goindex 36a892ede..8ea7c2ac8 100644--- a/internal/agent/tools/shell_exec.go+++ b/internal/agent/tools/shell_exec.go@@ -361,7 +361,8 @@ func (t *ShellExecTool) Execute(ctx context.Context, args json.RawMessage) (*typ}, nil}if reason := checkShellExecBlacklist(command); reason != "" {- logger.Warnf(ctx, "[Tool][ShellExec] rejected by blacklist: %s command=%q", reason, command)+ logger.Warnf(ctx, "[Tool][ShellExec] rejected by blacklist: %s command=%q",+ reason, maskCommandAssignments(command))return &types.ToolResult{Success: false,Error: fmt.Sprintf("command rejected by shell_exec safety guard: %s", reason),@@ -404,13 +405,18 @@ func (t *ShellExecTool) Execute(ctx context.Context, args json.RawMessage) (*typ}logger.Infof(ctx, "[Tool][ShellExec] session=%s work_dir=%s timeout=%s command=%q",- sessionID, workDir, timeout, command)+ sessionID, workDir, timeout, maskCommandAssignments(command))// The caller's config-wide variables apply to every command; a skill's// declared credentials are added only when the model names the skill.// Values come from ctx (the current principal), live only for this process,// and are overlaid without displacing anything the model passed via env.env := input.Env+ // supplied carries the values this one call brings with it, from the env+ // parameter and from NAME=value assignments in the command. They satisfy a+ // required variable that is not stored yet, which is what makes "tell me+ // the key in chat" work, and they are the only values capture may persist.+ supplied := collectUsedSkillEnv(input.Command, input.Env)if t.envResolver != nil {resolved, missing, rerr := t.envResolver.ResolveEnv(ctx, input.SkillName)if rerr != nil {@@ -419,12 +425,14 @@ func (t *ShellExecTool) Execute(ctx context.Context, args json.RawMessage) (*typError: fmt.Sprintf("failed to resolve environment variables: %v", rerr),}, nil}+ missing = stillMissing(missing, supplied)if len(missing) > 0 {return &types.ToolResult{Success: false,Error: fmt.Sprintf("skill %q needs the environment variable(s) %s, which nobody has set yet. "+- "Set them under Settings → Environment variables and try again.",+ "Ask the user for them and pass them in this call's env, "++ "or have them set the values under Settings → Environment variables.",input.SkillName, strings.Join(missing, ", ")),}, nil}@@ -432,6 +440,10 @@ func (t *ShellExecTool) Execute(ctx context.Context, args json.RawMessage) (*typenv = make(map[string]string)}overlayResolvedEnv(env, resolved)+ // A name that already resolved is one the workspace or this caller has+ // filled in. Capture must not touch it: otherwise a hallucinated+ // `export KEY=test` would overwrite a working stored credential.+ supplied = dropResolvedNames(supplied, resolved)}res, err := t.executor.ExecShellCommand(ctx, sessionID, command, workDir, timeout, env)if err != nil {@@ -443,7 +455,7 @@ func (t *ShellExecTool) Execute(ctx context.Context, args json.RawMessage) (*typ}, nil}- t.maybeCaptureSkillEnv(ctx, input, res)+ t.maybeCaptureSkillEnv(ctx, input.SkillName, supplied, res)outputLimit := resolveShellOutputLimit(input.MaxOutputBytes)stderrLimit := resolveShellStderrLimit(input.MaxStderrBytes)@@ -540,8 +552,15 @@ func (t *ShellExecTool) Execute(ctx context.Context, args json.RawMessage) (*typ}, nil}+// maybeCaptureSkillEnv persists the credentials this call brought with it, so+// the next run of the same skill does not have to ask again.+//+// The skill must be named explicitly: inferring it from a path in the command+// would let any successful command that merely mentions a skill directory write+// into that skill's credentials. pairs has already had every resolved name+// removed, so this only ever fills a blank.func (t *ShellExecTool) maybeCaptureSkillEnv(- ctx context.Context, input ShellExecInput, res *sandbox.ExecuteResult,+ ctx context.Context, skillName string, pairs map[string]string, res *sandbox.ExecuteResult,) {if t == nil || t.envCapture == nil || t.isInstallMode() {return@@ -549,17 +568,42 @@ func (t *ShellExecTool) maybeCaptureSkillEnv(if res == nil || res.ExitCode != 0 {return}- skillName := inferSkillName(input.SkillName, input.Command)- if skillName == "" {- return- }- pairs := collectUsedSkillEnv(input.Command, input.Env)- if len(pairs) == 0 {+ skillName = strings.TrimSpace(skillName)+ if !sandbox.IsValidSkillName(skillName) || len(pairs) == 0 {return}t.envCapture(ctx, skillName, pairs)}+// stillMissing removes from missing every name this call supplied itself.+func stillMissing(missing []string, supplied map[string]string) []string {+ if len(missing) == 0 || len(supplied) == 0 {+ return missing+ }+ out := missing[:0:0]+ for _, name := range missing {+ if strings.TrimSpace(supplied[name]) == "" {+ out = append(out, name)+ }+ }+ return out+}++// dropResolvedNames returns the supplied values that nothing has stored yet.+func dropResolvedNames(supplied, resolved map[string]string) map[string]string {+ if len(supplied) == 0 || len(resolved) == 0 {+ return supplied+ }+ out := make(map[string]string, len(supplied))+ for name, value := range supplied {+ if _, stored := resolved[name]; stored {+ continue+ }+ out[name] = value+ }+ return out+}+func (t *ShellExecTool) isInstallMode() bool {for _, root := range t.workDirRoots {if root == sandbox.SkillsImageRoot {diff --git a/internal/agent/tools/shell_exec_test.go b/internal/agent/tools/shell_exec_test.goindex 43926ec17..24b4da009 100644--- a/internal/agent/tools/shell_exec_test.go+++ b/internal/agent/tools/shell_exec_test.go@@ -211,12 +211,26 @@ func (r *recordedCapture) capture(_ context.Context, skillName string, pairs mapr.pairs = pairs}+// stubEnvResolver stands in for the service-layer resolver: resolved is what+// the workspace or this caller already has stored, missing is what a required+// declaration still needs.+type stubEnvResolver struct {+ resolved map[string]string+ missing []string+}++func (r stubEnvResolver) ResolveEnv(+ _ context.Context, _ string,+) (map[string]string, []string, error) {+ return r.resolved, r.missing, nil+}+func TestShellExecCapturesUsedEnvAfterSuccessfulCommand(t *testing.T) {recorder := &recordedCapture{}tool := NewShellExecTool(&fakeShellExecutor{}, nil).WithEnvCapture(recorder.capture)result, err := tool.Execute(shellExecTestContext(), json.RawMessage(- `{"command":"export USER_TOKEN=from-command; cd /opt/weknora/tenant/skills/pdf-tools && python x.py","env":{"EXTRA_TOKEN":"from-tool"}}`,+ `{"command":"export USER_TOKEN=from-command; python x.py","skill_name":"pdf-tools","env":{"EXTRA_TOKEN":"from-tool"}}`,))require.NoError(t, err)@@ -227,13 +241,76 @@ func TestShellExecCapturesUsedEnvAfterSuccessfulCommand(t *testing.T) {require.Equal(t, "from-tool", recorder.pairs["EXTRA_TOKEN"])}+// Guessing the skill from a path would let any successful command that merely+// mentions a skill directory write into that skill's credentials.+func TestShellExecDoesNotCaptureWithoutAnExplicitSkillName(t *testing.T) {+ recorder := &recordedCapture{}+ tool := NewShellExecTool(&fakeShellExecutor{}, nil).WithEnvCapture(recorder.capture)++ result, err := tool.Execute(shellExecTestContext(), json.RawMessage(+ `{"command":"export USER_TOKEN=from-command; cd /opt/weknora/tenant/skills/pdf-tools && python x.py"}`,+ ))++ require.NoError(t, err)+ require.True(t, result.Success)+ require.Zero(t, recorder.calls)+}++// A stored value belongs to whoever entered it. Capture may fill a blank, so a+// name that resolved is never handed to the write path.+func TestShellExecDoesNotCaptureAlreadyResolvedNames(t *testing.T) {+ recorder := &recordedCapture{}+ resolver := stubEnvResolver{resolved: map[string]string{"USER_TOKEN": "stored"}}+ tool := NewShellExecTool(&fakeShellExecutor{}, resolver).WithEnvCapture(recorder.capture)++ result, err := tool.Execute(shellExecTestContext(), json.RawMessage(+ `{"command":"python x.py","skill_name":"pdf-tools","env":{"USER_TOKEN":"model-made-this-up","NEW_TOKEN":"fresh"}}`,+ ))++ require.NoError(t, err)+ require.True(t, result.Success)+ require.Equal(t, 1, recorder.calls)+ require.NotContains(t, recorder.pairs, "USER_TOKEN")+ require.Equal(t, "fresh", recorder.pairs["NEW_TOKEN"])+}++// Refusing a required variable the call itself carries would strand every user+// without a settings page, since the value can only arrive through the chat.+func TestShellExecRunsWhenTheCallSuppliesTheMissingRequiredValue(t *testing.T) {+ recorder := &recordedCapture{}+ resolver := stubEnvResolver{missing: []string{"USER_TOKEN"}}+ tool := NewShellExecTool(&fakeShellExecutor{}, resolver).WithEnvCapture(recorder.capture)++ result, err := tool.Execute(shellExecTestContext(), json.RawMessage(+ `{"command":"python x.py","skill_name":"pdf-tools","env":{"USER_TOKEN":"typed-in-chat"}}`,+ ))++ require.NoError(t, err)+ require.True(t, result.Success)+ require.Equal(t, "typed-in-chat", recorder.pairs["USER_TOKEN"],+ "the value that made the run possible is the one worth storing")+}++func TestShellExecStillRefusesAMissingRequiredValueNobodySupplied(t *testing.T) {+ resolver := stubEnvResolver{missing: []string{"USER_TOKEN"}}+ tool := NewShellExecTool(&fakeShellExecutor{}, resolver)++ result, err := tool.Execute(shellExecTestContext(), json.RawMessage(+ `{"command":"python x.py","skill_name":"pdf-tools"}`,+ ))++ require.NoError(t, err)+ require.False(t, result.Success)+ require.Contains(t, result.Error, "USER_TOKEN")+}+func TestShellExecDoesNotCaptureWhenCommandFails(t *testing.T) {recorder := &recordedCapture{}tool := NewShellExecTool(&fakeShellExecutor{result: &sandbox.ExecuteResult{ExitCode: 1}}, nil).WithEnvCapture(recorder.capture)result, err := tool.Execute(shellExecTestContext(), json.RawMessage(- `{"command":"export USER_TOKEN=x; cd /opt/weknora/tenant/skills/pdf-tools && false"}`,+ `{"command":"export USER_TOKEN=x; false","skill_name":"pdf-tools"}`,))require.NoError(t, err)@@ -247,7 +324,7 @@ func TestShellExecDoesNotCaptureWhenExecutorErrors(t *testing.T) {WithEnvCapture(recorder.capture)result, err := tool.Execute(shellExecTestContext(), json.RawMessage(- `{"command":"export USER_TOKEN=x; cd /opt/weknora/tenant/skills/pdf-tools && true"}`,+ `{"command":"export USER_TOKEN=x; true","skill_name":"pdf-tools"}`,))require.NoError(t, err)@@ -260,7 +337,7 @@ func TestInstallShellExecDoesNotCapture(t *testing.T) {tool := NewInstallShellExecTool(&fakeInstallShellExecutor{}).WithEnvCapture(recorder.capture)result, err := tool.Execute(shellExecTestContext(), json.RawMessage(- `{"command":"export USER_TOKEN=x; cd /opt/weknora/tenant/skills/pdf-tools && pip install x"}`,+ `{"command":"export USER_TOKEN=x; pip install x","skill_name":"pdf-tools"}`,))require.NoError(t, err)diff --git a/internal/application/repository/tenant_skill.go b/internal/application/repository/tenant_skill.goindex ce6c285da..6fc39e90d 100644--- a/internal/application/repository/tenant_skill.go+++ b/internal/application/repository/tenant_skill.go@@ -25,8 +25,22 @@ type TenantSkillRepository interface {// ListSkillsByTenant spans every sandbox config of one workspace, for the// views that are about the user rather than about a config.ListSkillsByTenant(ctx context.Context, tenantID uint64) ([]*types.TenantSkillEntity, error)- // UpdateSkill writes the mutable projection fields after install/remove state changes.+ // UpdateSkill writes the mutable projection fields after install/remove+ // state changes. It never touches envs; see the implementation.UpdateSkill(ctx context.Context, e *types.TenantSkillEntity) error+ // UpdateSkillEnvs writes the declared environment variables alone.+ UpdateSkillEnvs(+ ctx context.Context, tenantID uint64, configID, skillID string, envs types.SkillEnvVars,+ ) error+ // UpdateSkillAdminState writes visibility and declared values together, as+ // one admin request.+ UpdateSkillAdminState(+ ctx context.Context,+ tenantID uint64,+ configID, skillID string,+ enabled bool,+ envs types.SkillEnvVars,+ ) error// DeleteSkill soft-deletes the metadata row and, in the same transaction,// hard-deletes the per-principal env values hanging off it. Image cleanup is// represented by snapshots. When the scoped key matches no skill, nothing is@@ -142,6 +156,13 @@ func (r *tenantSkillRepository) ListSkillsByTenant(// UpdateSkill writes the mutable columns explicitly so a zero-valued field on// the passed entity cannot silently wipe state written by a concurrent job.+//+// envs is deliberately absent: it is the one column an install-progress write+// has no opinion about, and every such write is a read-modify-write of a row+// the install heartbeat reloads every 30 seconds. Including it would let a+// heartbeat that read the row a moment before a declaration was recorded put+// the stale list — or a NULL — back. UpdateSkillEnvs and UpdateSkillAdminState+// are the only writers of that column.func (r *tenantSkillRepository) UpdateSkill(ctx context.Context, e *types.TenantSkillEntity) error {return r.db.WithContext(ctx).Model(&types.TenantSkillEntity{}).@@ -154,7 +175,6 @@ func (r *tenantSkillRepository) UpdateSkill(ctx context.Context, e *types.Tenant"bundle_ref": e.BundleRef,"bundle_sha256": e.BundleSHA256,"enabled": e.Enabled,- "envs": e.Envs,"installed_snapshot_id": e.InstalledSnapshotID,"install_session_id": e.InstallSessionID,"install_message_id": e.InstallMessageID,@@ -165,6 +185,37 @@ func (r *tenantSkillRepository) UpdateSkill(ctx context.Context, e *types.Tenant}).Error}+// UpdateSkillEnvs writes the declaration column alone, so recording what a+// skill needs cannot disturb the install state written next to it.+func (r *tenantSkillRepository) UpdateSkillEnvs(+ ctx context.Context, tenantID uint64, configID, skillID string, envs types.SkillEnvVars,+) error {+ return r.db.WithContext(ctx).+ Model(&types.TenantSkillEntity{}).+ Where("tenant_id = ? AND sandbox_config_id = ? AND id = ?", tenantID, configID, skillID).+ Updates(map[string]any{"envs": envs, "updated_at": time.Now()}).Error+}++// UpdateSkillAdminState writes the two columns an admin request owns, together,+// so a rotation that disables the skill and clears its value is one statement+// rather than two that can half apply.+func (r *tenantSkillRepository) UpdateSkillAdminState(+ ctx context.Context,+ tenantID uint64,+ configID, skillID string,+ enabled bool,+ envs types.SkillEnvVars,+) error {+ return r.db.WithContext(ctx).+ Model(&types.TenantSkillEntity{}).+ Where("tenant_id = ? AND sandbox_config_id = ? AND id = ?", tenantID, configID, skillID).+ Updates(map[string]any{+ "enabled": enabled,+ "envs": envs,+ "updated_at": time.Now(),+ }).Error+}+// DeleteSkill soft-deletes the skill and hard-deletes the user values that// belonged to it, in one transaction. The cleanup cannot be a cascading foreign// key: tenant_skills is soft-deleted, so ON DELETE CASCADE would never fire anddiff --git a/internal/application/repository/tenant_skill_test.go b/internal/application/repository/tenant_skill_test.goindex cf9f47f5a..3beb3e697 100644--- a/internal/application/repository/tenant_skill_test.go+++ b/internal/application/repository/tenant_skill_test.go@@ -186,19 +186,16 @@ func userEnvRow(p types.Principal, skillID, name, value string) *types.TenantUse}}-func TestSkillRepoUpdatePersistsEnvs(t *testing.T) {+func TestSkillRepoUpdateSkillEnvsPersistsTheDeclarationEncrypted(t *testing.T) {t.Setenv("SYSTEM_AES_KEY", skillEnvTestAESKey)repo, db := newSkillTestRepoWithDB(t)ctx := context.Background()require.NoError(t, repo.CreateSkill(ctx, skillRow("sk-a", "cfg-1", "pdf")))- row, err := repo.GetSkill(ctx, 7, "cfg-1", "sk-a")- require.NoError(t, err)- row.Envs = types.SkillEnvVars{+ require.NoError(t, repo.UpdateSkillEnvs(ctx, 7, "cfg-1", "sk-a", types.SkillEnvVars{{Name: "TAVILY_API_KEY", Description: "search key", Required: true, Value: "tvly-admin"},{Name: "OPTIONAL_KEY"},- }- require.NoError(t, repo.UpdateSkill(ctx, row))+ }))got, err := repo.GetSkill(ctx, 7, "cfg-1", "sk-a")require.NoError(t, err)@@ -214,6 +211,47 @@ func TestSkillRepoUpdatePersistsEnvs(t *testing.T) {require.Contains(t, stored, "TAVILY_API_KEY", "the declaration stays readable without a key")}+// The install heartbeat rewrites the whole row from a copy it read seconds+// earlier. If UpdateSkill carried envs, that copy would undo a declaration or+// an admin value stored in between.+func TestSkillRepoUpdateSkillLeavesEnvsAlone(t *testing.T) {+ t.Setenv("SYSTEM_AES_KEY", skillEnvTestAESKey)+ repo, _ := newSkillTestRepoWithDB(t)+ ctx := context.Background()+ require.NoError(t, repo.CreateSkill(ctx, skillRow("sk-a", "cfg-1", "pdf")))++ stale, err := repo.GetSkill(ctx, 7, "cfg-1", "sk-a")+ require.NoError(t, err)+ require.NoError(t, repo.UpdateSkillEnvs(ctx, 7, "cfg-1", "sk-a", types.SkillEnvVars{+ {Name: "TAVILY_API_KEY", Required: true, Value: "tvly-admin"},+ }))++ stale.Status = types.SkillStatusInstalling+ require.NoError(t, repo.UpdateSkill(ctx, stale))++ got, err := repo.GetSkill(ctx, 7, "cfg-1", "sk-a")+ require.NoError(t, err)+ require.Equal(t, types.SkillStatusInstalling, got.Status)+ require.Len(t, got.Envs, 1)+ require.Equal(t, "tvly-admin", got.Envs[0].Value)+}++func TestSkillRepoUpdateSkillAdminStateWritesBothColumns(t *testing.T) {+ t.Setenv("SYSTEM_AES_KEY", skillEnvTestAESKey)+ repo, _ := newSkillTestRepoWithDB(t)+ ctx := context.Background()+ require.NoError(t, repo.CreateSkill(ctx, skillRow("sk-a", "cfg-1", "pdf")))++ require.NoError(t, repo.UpdateSkillAdminState(ctx, 7, "cfg-1", "sk-a", false,+ types.SkillEnvVars{{Name: "TAVILY_API_KEY", Value: "tvly-admin"}}))++ got, err := repo.GetSkill(ctx, 7, "cfg-1", "sk-a")+ require.NoError(t, err)+ require.False(t, got.Enabled)+ require.Len(t, got.Envs, 1)+ require.Equal(t, "tvly-admin", got.Envs[0].Value)+}+func TestUpsertUserEnvIsIdempotentPerPrincipalSkillAndName(t *testing.T) {t.Setenv("SYSTEM_AES_KEY", skillEnvTestAESKey)repo, db := newSkillTestRepoWithDB(t)diff --git a/internal/application/service/agent_service.go b/internal/application/service/agent_service.goindex 02a29a90f..e0b48b975 100644--- a/internal/application/service/agent_service.go+++ b/internal/application/service/agent_service.go@@ -608,7 +608,7 @@ func (s *agentService) registerSandboxShellTool(return}if executor := sessionSandboxShellExecutor(sandboxMgr); executor != nil {- resolver := s.userEnvResolver(ctx, config) // 现取,可能为 nil+ resolver := s.userEnvResolver(ctx, config)toolRegistry.RegisterTool(tools.NewShellExecTool(executor, resolver).WithEnvCapture(s.skillEnvCapture(config)),)diff --git a/internal/application/service/tenant_skill_admin.go b/internal/application/service/tenant_skill_admin.goindex 6eff88c2a..3aea6f7ba 100644--- a/internal/application/service/tenant_skill_admin.go+++ b/internal/application/service/tenant_skill_admin.go@@ -118,7 +118,12 @@ func (s *TenantSkillService) UpdateSkillAdmin(if !changed {return skill, nil}- if err := s.skills.UpdateSkill(ctx, skill); err != nil {+ // Only the two admin-owned columns are written: the row may be mid-install,+ // and the status the installer is keeping there is none of this request's+ // business.+ if err := s.skills.UpdateSkillAdminState(+ ctx, tenantID, configID, skillID, skill.Enabled, skill.Envs,+ ); err != nil {return nil, err}return skill, nildiff --git a/internal/application/service/tenant_skill_admin_test.go b/internal/application/service/tenant_skill_admin_test.goindex ec2c87b51..06b131eb9 100644--- a/internal/application/service/tenant_skill_admin_test.go+++ b/internal/application/service/tenant_skill_admin_test.go@@ -93,10 +93,7 @@ func TestSetSkillEnabledReturnsNilForAnotherWorkspace(t *testing.T) {// finished install would have left it.func seedSkillEnvDeclaration(t *testing.T, fx *installFixture, envs types.SkillEnvVars) {t.Helper()- skill, err := fx.skillRepo.GetSkill(context.Background(), 7, "cfg-1", "sk-1")- require.NoError(t, err)- skill.Envs = envs- require.NoError(t, fx.skillRepo.UpdateSkill(context.Background(), skill))+ require.NoError(t, fx.skillRepo.UpdateSkillEnvs(context.Background(), 7, "cfg-1", "sk-1", envs))}// A name outside the declaration is ignored rather than rejected: a stale UIdiff --git a/internal/application/service/tenant_skill_install.go b/internal/application/service/tenant_skill_install.goindex ce493542b..3290952fe 100644--- a/internal/application/service/tenant_skill_install.go+++ b/internal/application/service/tenant_skill_install.go@@ -1698,8 +1698,8 @@ func (s *TenantSkillService) recordEnvDeclaration(logger.Warnf(ctx, "[skill] load %s to store its env declaration failed: %v", skillID, err)return}- skill.Envs = mergeEnvDeclaration(skill.Envs, envs)- if err := s.skills.UpdateSkill(ctx, skill); err != nil {+ merged := mergeEnvDeclaration(skill.Envs, envs)+ if err := s.skills.UpdateSkillEnvs(ctx, tenantID, configID, skillID, merged); err != nil {logger.Warnf(ctx, "[skill] store the env declaration of %s failed: %v", skillID, err)}}diff --git a/internal/application/service/tenant_skill_install_test.go b/internal/application/service/tenant_skill_install_test.goindex 3ed231f32..8484ab939 100644--- a/internal/application/service/tenant_skill_install_test.go+++ b/internal/application/service/tenant_skill_install_test.go@@ -355,12 +355,10 @@ func TestRunInstallSucceedsWhenEveryDeclaredEnvVarIsRejected(t *testing.T) {func TestRunInstallReinstallKeepsTheAdminValueAndDropsStaleVars(t *testing.T) {fx := newInstallFixture(t)fx.readsTavilyKey()- require.NoError(t, fx.svc.updateSkillFields(context.Background(), 7, "cfg-1", "sk-1",- func(e *types.TenantSkillEntity) {- e.Envs = types.SkillEnvVars{- {Name: "TAVILY_API_KEY", Description: "old text", Value: "tvly-typed-by-admin"},- {Name: "LEGACY_TOKEN", Required: true, Value: "stale"},- }+ require.NoError(t, fx.skillRepo.UpdateSkillEnvs(context.Background(), 7, "cfg-1", "sk-1",+ types.SkillEnvVars{+ {Name: "TAVILY_API_KEY", Description: "old text", Value: "tvly-typed-by-admin"},+ {Name: "LEGACY_TOKEN", Required: true, Value: "stale"},}))fx.declareEnvFile(`{"env":[{"name":"TAVILY_API_KEY","description":"new text","required":true}]}`)@@ -420,10 +418,8 @@ func TestRunInstallReinstallOnlyClearsEnvsForAnExplicitEmptyDeclaration(t *testifor _, tc := range cases {t.Run(tc.name, func(t *testing.T) {fx := newInstallFixture(t)- require.NoError(t, fx.svc.updateSkillFields(context.Background(), 7, "cfg-1", "sk-1",- func(e *types.TenantSkillEntity) {- e.Envs = storedAdminEnv()- }))+ require.NoError(t, fx.skillRepo.UpdateSkillEnvs(+ context.Background(), 7, "cfg-1", "sk-1", storedAdminEnv()))if tc.writeFile {fx.declareEnvFile(tc.body)}@@ -841,6 +837,28 @@ func TestBeatInstallHeartbeatRestampsOnlyAnInstallingRow(t *testing.T) {"a row that left the installing status must not be stamped alive again")}+// The heartbeat reloads and rewrites the whole row every 30 seconds while an+// install runs, and a declaration or an admin value can be stored in between.+// Writing envs from that stale copy would put the old list back.+func TestBeatInstallHeartbeatLeavesTheDeclarationAlone(t *testing.T) {+ fx := newInstallFixture(t)+ ctx := context.Background()+ stale := fx.now().Add(-time.Hour)+ require.NoError(t, fx.svc.updateSkillFields(ctx, 7, "cfg-1", "sk-1",+ func(e *types.TenantSkillEntity) { e.InstallingSince = &stale }))++ // Stands in for the beat that read the row before the declaration landed.+ before, err := fx.skillRepo.GetSkill(ctx, 7, "cfg-1", "sk-1")+ require.NoError(t, err)+ require.NoError(t, fx.skillRepo.UpdateSkillEnvs(ctx, 7, "cfg-1", "sk-1", storedAdminEnv()))+ require.NoError(t, fx.skillRepo.UpdateSkill(ctx, before))++ skill, err := fx.skillRepo.GetSkill(ctx, 7, "cfg-1", "sk-1")+ require.NoError(t, err)+ require.Equal(t, storedAdminEnv(), skill.Envs,+ "an install-progress write must not carry an old declaration back")+}+func TestStartInstallHeartbeatBeatsUntilStopped(t *testing.T) {fx := newInstallFixture(t)ctx := context.Background()@@ -1959,8 +1977,54 @@ func (r *installSkillRepo) UpdateSkill(ctx context.Context, e *types.TenantSkillif r.updateFailsWhen != nil && r.updateFailsWhen(e) {return errUpdateBoom}+ key := skillKey(e.TenantID, e.SandboxConfigID, e.ID)cp := *e- r.skills[skillKey(e.TenantID, e.SandboxConfigID, e.ID)] = &cp+ // The real UpdateSkill leaves the envs column alone, so a stale in-memory+ // copy cannot put an old declaration back. The fake has to model that or+ // the tests would pass on behaviour production does not have.+ if stored := r.skills[key]; stored != nil {+ cp.Envs = stored.Envs+ } else {+ cp.Envs = nil+ }+ r.skills[key] = &cp+ return nil+}++func (r *installSkillRepo) UpdateSkillEnvs(+ ctx context.Context, tenantID uint64, configID, skillID string, envs types.SkillEnvVars,+) error {+ if err := ctx.Err(); err != nil {+ return err+ }+ r.mu.Lock()+ defer r.mu.Unlock()+ stored := r.skills[skillKey(tenantID, configID, skillID)]+ if stored == nil {+ return nil+ }+ stored.Envs = envs+ return nil+}++func (r *installSkillRepo) UpdateSkillAdminState(+ ctx context.Context,+ tenantID uint64,+ configID, skillID string,+ enabled bool,+ envs types.SkillEnvVars,+) error {+ if err := ctx.Err(); err != nil {+ return err+ }+ r.mu.Lock()+ defer r.mu.Unlock()+ stored := r.skills[skillKey(tenantID, configID, skillID)]+ if stored == nil {+ return nil+ }+ stored.Enabled = enabled+ stored.Envs = envsreturn nil}diff --git a/internal/application/service/tenant_skill_reaper_test.go b/internal/application/service/tenant_skill_reaper_test.goindex 1a34d9ce1..0029ea724 100644--- a/internal/application/service/tenant_skill_reaper_test.go+++ b/internal/application/service/tenant_skill_reaper_test.go@@ -781,10 +781,34 @@ func (r *reaperSkillStore) GetSkill(func (r *reaperSkillStore) UpdateSkill(_ context.Context, e *types.TenantSkillEntity) error {cp := *e+ if stored := r.rows[e.ID]; stored != nil {+ cp.Envs = stored.Envs+ } else {+ cp.Envs = nil+ }r.rows[e.ID] = &cpreturn nil}+func (r *reaperSkillStore) UpdateSkillEnvs(+ _ context.Context, _ uint64, _, skillID string, envs types.SkillEnvVars,+) error {+ if stored := r.rows[skillID]; stored != nil {+ stored.Envs = envs+ }+ return nil+}++func (r *reaperSkillStore) UpdateSkillAdminState(+ _ context.Context, _ uint64, _, skillID string, enabled bool, envs types.SkillEnvVars,+) error {+ if stored := r.rows[skillID]; stored != nil {+ stored.Enabled = enabled+ stored.Envs = envs+ }+ return nil+}+func (r *reaperSkillStore) ListSnapshotsByConfig(_ context.Context, tenantID uint64, configID string,) ([]*types.TenantSkillSnapshotEntity, error) {diff --git a/internal/application/service/user_env.go b/internal/application/service/user_env.goindex ddea21cf0..80cdc477b 100644--- a/internal/application/service/user_env.go+++ b/internal/application/service/user_env.go@@ -223,10 +223,15 @@ func applyOwnValue(view *EnvVarView, own *types.TenantUserEnvVar) {}// CaptureSkillEnv stores values a successful skill run already used, for the-// current principal only. It writes only names that skill declared; reserved-// names and a value that already matches the stored user row or the workspace-// admin value are skipped. Unknown or unusable skills are a no-op so a-// mis-inferred name cannot create a row.+// current principal only. It writes only names that skill declared, and only+// names nothing has filled in yet: a value already stored by this caller or by+// the workspace is left alone.+//+// Filling blanks is the whole contract. Rotation belongs to the settings page,+// where a person chose the new value; a value read out of a command the model+// composed is not that, and letting it overwrite a working credential would+// turn one hallucinated `export KEY=test` into a permanently broken skill.+// Unknown or unusable skills are a no-op.func (s *UserEnvService) CaptureSkillEnv(ctx context.Context, configID, skillName string, pairs map[string]string,) error {@@ -269,10 +274,10 @@ func (s *UserEnvService) CaptureSkillEnv(if !ok {continue}- if declared.Value != "" && declared.Value == value {+ if declared.Value != "" {continue}- if existing := mine[name]; existing != nil && existing.Value == value {+ if existing := mine[name]; existing != nil && existing.Value != "" {continue}if err := s.upsertMine(ctx, tenantID, principal, configID, skill.ID, name, value); err != nil {diff --git a/internal/application/service/user_env_test.go b/internal/application/service/user_env_test.goindex faee2502e..733aeddce 100644--- a/internal/application/service/user_env_test.go+++ b/internal/application/service/user_env_test.go@@ -453,7 +453,10 @@ func TestCaptureSkillEnvDoesNotCopyAdminValueIntoUserSlot(t *testing.T) {require.Empty(t, repo.userEnvs)}-func TestCaptureSkillEnvWritesUserOverrideOfAdminValue(t *testing.T) {+// A workspace value is one an admin typed. A value read out of a command the+// model composed must not displace it for this caller — that is what the+// settings page is for.+func TestCaptureSkillEnvLeavesTheAdminValueInPlace(t *testing.T) {svc, repo := newUserEnvFixture(t)require.NoError(t, svc.CaptureSkillEnv(@@ -461,7 +464,7 @@ func TestCaptureSkillEnvWritesUserOverrideOfAdminValue(t *testing.T) {"API_TOKEN": "alice-override",}))- require.Equal(t, "alice-override", userEnvByName(t, repo.userEnvs, "API_TOKEN").Value)+ require.Empty(t, repo.userEnvs)}func TestCaptureSkillEnvSkipsWhenUserValueAlreadyMatches(t *testing.T) {@@ -478,7 +481,10 @@ func TestCaptureSkillEnvSkipsWhenUserValueAlreadyMatches(t *testing.T) {require.Equal(t, "already-mine", repo.userEnvs[0].Value)}-func TestCaptureSkillEnvRotatesADifferentUserValue(t *testing.T) {+// Capture fills blanks and nothing else. A prompt injection, a hallucination or+// one `export TOKEN=test` must not be able to replace a key its owner entered,+// which nobody would notice until every later turn authenticated as nobody.+func TestCaptureSkillEnvNeverOverwritesAStoredUserValue(t *testing.T) {svc, repo := newUserEnvFixture(t)ctx := userEnvCtx(userEnvTenantID, "alice")require.NoError(t, svc.SetMineSkill(ctx, "sk-ready", "USER_TOKEN", "old-key"))@@ -488,7 +494,7 @@ func TestCaptureSkillEnvRotatesADifferentUserValue(t *testing.T) {}))require.Len(t, repo.userEnvs, 1)- require.Equal(t, "new-key", repo.userEnvs[0].Value)+ require.Equal(t, "old-key", repo.userEnvs[0].Value)}func TestCaptureSkillEnvIgnoresUnknownOrUnusableSkills(t *testing.T) {diff --git a/internal/types/tenant_env_vars.go b/internal/types/tenant_env_vars.goindex b9883a0e1..9015c8604 100644--- a/internal/types/tenant_env_vars.go+++ b/internal/types/tenant_env_vars.go@@ -4,6 +4,7 @@ import ("database/sql/driver""encoding/json""errors"+ "fmt""log""time"@@ -65,11 +66,15 @@ func (v SkillEnvVars) Value() (driver.Value, error) {}rows := make([]skillEnvVarRow, len(v))for i, entry := range v {+ encrypted, err := encryptEnvValue(entry.Value)+ if err != nil {+ return nil, fmt.Errorf("encrypt skill_env_vars.%s: %w", entry.Name, err)+ }rows[i] = skillEnvVarRow{Name: entry.Name,Description: entry.Description,Required: entry.Required,- Value: encryptEnvValue(entry.Value),+ Value: encrypted,}}return json.Marshal(rows)@@ -153,12 +158,22 @@ func (e *TenantUserEnvVar) BeforeCreate(tx *gorm.DB) error {if e.ID == "" {e.ID = uuid.New().String()}- e.Value = encryptEnvValue(e.Value)- return nil+ return e.encryptValue()}func (e *TenantUserEnvVar) BeforeSave(tx *gorm.DB) error {- e.Value = encryptEnvValue(e.Value)+ return e.encryptValue()+}++// encryptValue is idempotent: EncryptAESGCM returns an already-prefixed string+// unchanged, so the BeforeSave/BeforeCreate pair GORM runs on a create does not+// encrypt twice.+func (e *TenantUserEnvVar) encryptValue() error {+ encrypted, err := encryptEnvValue(e.Value)+ if err != nil {+ return fmt.Errorf("encrypt tenant_user_env_vars.%s: %w", e.Name, err)+ }+ e.Value = encryptedreturn nil}@@ -168,16 +183,23 @@ func (e *TenantUserEnvVar) AfterFind(tx *gorm.DB) error {}// encryptEnvValue returns the ciphertext, or the input unchanged when there is-// no key to encrypt with.-func encryptEnvValue(value string) string {+// no key configured to encrypt with — the same deployment-wide degradation+// every other secret column accepts.+//+// A key that exists but fails to encrypt is different: it means something is+// wrong with the cipher, and writing the plaintext into a queryable JSONB+// column instead would turn that into a silent leak. The error aborts the+// write, matching TenantAPIKey.BeforeSave.+func encryptEnvValue(value string) (string, error) {key := utils.GetAESKey()if key == nil || value == "" {- return value+ return value, nil}- if encrypted, err := utils.EncryptAESGCM(value, key); err == nil {- return encrypted+ encrypted, err := utils.EncryptAESGCM(value, key)+ if err != nil {+ return "", err}- return value+ return encrypted, nil}// decryptEnvValue reports an unreadable secret as unset rather than failing thediff --git a/internal/types/tenant_env_vars_test.go b/internal/types/tenant_env_vars_test.goindex f3329634d..b7875cf5f 100644--- a/internal/types/tenant_env_vars_test.go+++ b/internal/types/tenant_env_vars_test.go@@ -142,6 +142,32 @@ func TestTenantUserEnvVarNeverSerialisesItsValue(t *testing.T) {require.Contains(t, string(raw), "TAVILY_API_KEY")}+// GORM runs BeforeSave and BeforeCreate one after the other on a create, and+// both encrypt. Encrypting twice would store a value nothing can read back.+func TestTenantUserEnvVarEncryptsOnceAcrossBothHooks(t *testing.T) {+ t.Setenv("SYSTEM_AES_KEY", skillEnvAESKey)+ row := &TenantUserEnvVar{Name: "TAVILY_API_KEY", Value: "tvly-super-secret"}++ require.NoError(t, row.BeforeSave(nil))+ require.NoError(t, row.BeforeCreate(nil))++ require.NotEmpty(t, row.ID, "BeforeCreate still assigns the primary key")+ require.True(t, strings.HasPrefix(row.Value, utils.EncPrefix))+ plain, ok := utils.DecryptStoredSecretLenient(row.Value)+ require.True(t, ok)+ require.Equal(t, "tvly-super-secret", plain)+}++// Without a key configured there is nothing to encrypt with, which is the+// deployment-wide degradation every secret column in this repo accepts.+func TestTenantUserEnvVarKeepsTheValueWhenNoKeyIsConfigured(t *testing.T) {+ t.Setenv("SYSTEM_AES_KEY", "")+ row := &TenantUserEnvVar{Name: "TAVILY_API_KEY", Value: "tvly-super-secret"}++ require.NoError(t, row.BeforeSave(nil))+ require.Equal(t, "tvly-super-secret", row.Value)+}+func TestTenantUserEnvVarAfterFindTreatsUndecryptableValueAsUnset(t *testing.T) {t.Setenv("SYSTEM_AES_KEY", skillEnvAESKey)var logs bytes.Bufferdiff --git a/migrations/versioned/000089_env_vars.up.sql b/migrations/versioned/000089_env_vars.up.sqlindex 2213f0e9b..7e59f9f65 100644--- a/migrations/versioned/000089_env_vars.up.sql+++ b/migrations/versioned/000089_env_vars.up.sql@@ -7,14 +7,14 @@-- is injected into every execution on it; one with a skill_id is that skill's-- declared credential, injected only when a tool names the skill. The storage is-- shared because it is the same kind of thing — only the load timing differs.-DO $$ BEGIN RAISE NOTICE '[Migration 000088] Adding tenant_skills.envs'; END $$;+DO $$ BEGIN RAISE NOTICE '[Migration 000089] Adding tenant_skills.envs'; END $$;ALTER TABLE tenant_skills ADD COLUMN IF NOT EXISTS envs JSONB;COMMENT ON COLUMN tenant_skills.envs IS'Installer-agent declaration [{name,description,required,value}]. value is the workspace-wide admin value and is AES-GCM encrypted; the rest is plaintext so the UI can render it without a key.';-DO $$ BEGIN RAISE NOTICE '[Migration 000088] Creating tenant_user_env_vars'; END $$;+DO $$ BEGIN RAISE NOTICE '[Migration 000089] Creating tenant_user_env_vars'; END $$;CREATE TABLE IF NOT EXISTS tenant_user_env_vars (id VARCHAR(36) PRIMARY KEY,