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): advertise only image skills and unstick installs
wizardchen625f9db80a84
diff --git a/frontend/src/components/SandboxSkillsPanel.vue b/frontend/src/components/SandboxSkillsPanel.vueindex 15ec24e46..101c88ede 100644--- a/frontend/src/components/SandboxSkillsPanel.vue+++ b/frontend/src/components/SandboxSkillsPanel.vue@@ -125,7 +125,13 @@</p><ul class="skill-list">- <li v-for="skill in skills" :key="skill.id" class="skill-item">+ <li+ v-for="skill in skills"+ :key="skill.id"+ :ref="(el) => bindSkillItem(skill.id, el)"+ class="skill-item"+ :class="{ 'skill-item--focused': focusedSkillId === skill.id }"+ ><div class="skill-status-ring" :title="statusLabel(skill)"><t-progressv-if="isBusy(skill)"@@ -154,6 +160,7 @@<span v-if="skill.version">{{ skill.version }} · </span><span>{{ statusLabel(skill) }}</span><span v-if="isBusy(skill)"> · {{ progressOf(skill) }}%</span>+ <span v-if="isBusy(skill) && progressLog(skill)"> · {{ progressLog(skill) }}</span></p></div><div class="skill-item__actions">@@ -275,7 +282,7 @@</template><script setup lang="ts">-import { computed, onUnmounted, ref, watch } from 'vue'+import { computed, nextTick, onUnmounted, ref, watch } from 'vue'import { MessagePlugin } from 'tdesign-vue-next'import { useI18n } from 'vue-i18n'import { fetchEventSource } from '@microsoft/fetch-event-source'@@ -330,6 +337,9 @@ const deletingId = ref('')const expandedSkillId = ref('')const expandedCopyIds = ref<Set<string>>(new Set())const transcriptEpoch = ref(0)+const focusedSkillId = ref('')+const skillItemEls = new Map<string, HTMLElement>()+let focusTimer: number | null = nullconst fileInputRef = ref<HTMLInputElement | null>(null)const progressById = ref<Record<string, ConfigSkillInstallEvent>>({})@@ -408,6 +418,26 @@ function hasTranscript(skill: ConfigSkill): boolean {return Boolean(skill.install_session_id && skill.install_message_id)}+function bindSkillItem(id: string, el: unknown) {+ if (el instanceof HTMLElement) {+ skillItemEls.set(id, el)+ return+ }+ skillItemEls.delete(id)+}++function revealSkill(skillId: string) {+ focusedSkillId.value = skillId+ void nextTick(() => {+ skillItemEls.get(skillId)?.scrollIntoView({ behavior: 'smooth', block: 'center' })+ })+ if (focusTimer != null) window.clearTimeout(focusTimer)+ focusTimer = window.setTimeout(() => {+ if (focusedSkillId.value === skillId) focusedSkillId.value = ''+ focusTimer = null+ }, 2400)+}+function onTranscriptVisible(skill: ConfigSkill, visible: boolean) {if (visible) {if (expandedSkillId.value !== skill.id) {@@ -671,7 +701,10 @@ async function uploadFile(file: File) {const skillId = res?.data?.skill_idawait loadSkills()await refreshImage()- if (skillId) followProgress(skillId)+ if (skillId) {+ followProgress(skillId)+ revealSkill(skillId)+ }} catch (e: any) {MessagePlugin.error(e?.message || t('settings.sandbox.skillUploadFailed'))} finally {@@ -698,7 +731,10 @@ async function installFromSource() {const skillId = res?.data?.skill_idawait loadSkills()await refreshImage()- if (skillId) followProgress(skillId)+ if (skillId) {+ followProgress(skillId)+ revealSkill(skillId)+ }} catch (e: any) {MessagePlugin.error(e?.message || t('settings.sandbox.skillSourceFailed'))} finally {@@ -773,6 +809,7 @@ watch(onUnmounted(() => {stopAllFollows()stopPoll()+ if (focusTimer != null) window.clearTimeout(focusTimer)})</script>@@ -976,6 +1013,12 @@ onUnmounted(() => {border: 1px solid var(--td-component-stroke);border-radius: 8px;background: var(--td-bg-color-container);+ transition: border-color 0.2s ease, box-shadow 0.2s ease;+}++.skill-item--focused {+ border-color: var(--td-brand-color);+ box-shadow: 0 0 0 2px var(--td-brand-color-focus, rgba(0, 168, 112, 0.18));}.skill-transcript-toggle--on {diff --git a/frontend/src/components/SkillInstallTimeline.vue b/frontend/src/components/SkillInstallTimeline.vueindex e886881cc..480266310 100644--- a/frontend/src/components/SkillInstallTimeline.vue+++ b/frontend/src/components/SkillInstallTimeline.vue@@ -38,9 +38,9 @@ const props = defineProps<{// The durable rows behind the run, used when the event log has aged out.sessionId: stringmessageId: string- // True while this skill is still installing. The locators are written only- // after the installer sandbox is up, so a 404 here means "not yet" rather- // than "gone" and the stream is retried.+ // True while this skill is still installing. Locators are written after the+ // sandbox is up; until then this component shows the waiting copy and does+ // not hit /transcript.live?: booleancompact?: boolean}>()@@ -168,22 +168,30 @@ async function open() {const run = ++openRunclosed = falsemessages.splice(0, messages.length)- loading.value = trueconst stale = () => run !== openRun || closedtry {// A finished install already has durable rows. Replaying the event log// through processStreamChunk would animate every tool call again, which// is what "view the run" must not do.if (!props.live) {+ loading.value = trueif (props.sessionId) {await loadPersisted(run)}return}- // Locators land after the installer sandbox is up. Keep asking until the- // stream answers; falling through to the empty state on the first 404- // would flash "no record" during setup.+ // Locators land after the installer sandbox is up. Hitting /transcript+ // before that 404s every second (WARNING in the access log) and leaves+ // the spinner up for the entire file seed, which can take minutes.+ // The parent already polls the skill list; this watch re-opens when+ // sessionId arrives.+ if (!props.sessionId || !props.messageId) {+ loading.value = false+ return+ }++ loading.value = truefor (;;) {if (stale() || !props.live) returnconst served = await follow(run).catch(() => false)@@ -204,7 +212,7 @@ async function open() {}watch(- () => [props.configId, props.skillId, props.sessionId, props.live] as const,+ () => [props.configId, props.skillId, props.sessionId, props.messageId, props.live] as const,() => {stop()if (props.configId && props.skillId) void open()diff --git a/internal/agent/skills/manager.go b/internal/agent/skills/manager.goindex aea4887d2..4e99fa03d 100644--- a/internal/agent/skills/manager.go+++ b/internal/agent/skills/manager.go@@ -77,8 +77,9 @@ type Manager struct {sandboxMgr sandbox.Manager// tenantSource holds the skills installed into this run's sandbox image.- // It is nil for every run whose workspace has none, which is why the- // preloaded path below is untouched by its existence.+ // When set it is the only source the model is told about: the host+ // skills/preloaded directory is not what execute_skill_script would find+ // inside the sandbox.tenantSource SkillSource// Configuration@@ -129,70 +130,25 @@ func (m *Manager) WithTenantSource(source SkillSource) *Manager {return m}-// resolveSource decides which source owns one skill name. An installed skill-// shadows a preloaded one of the same name, because the sandbox boots the-// image the install produced and that is the copy a script would run.+// resolveSource decides which source owns one skill name. An installed image+// is the only copy the sandbox can run: falling back to a host preloaded+// skill would advertise files that are not in the image.func (m *Manager) resolveSource(skillName string) SkillSource {if m.tenantSource != nil {- if _, err := m.tenantSource.GetSkillBasePath(skillName); err == nil {- return m.tenantSource- }+ return m.tenantSource}return m.loader}-// discoverAllSkills merges the two sources into the set the model is told-// about.+// discoverAllSkills returns the set the model is told about. When skills are+// installed into the sandbox image, that image is the source of truth; the+// deployment's skills/preloaded directory is not what execute_skill_script+// would find inside the sandbox.func (m *Manager) discoverAllSkills() ([]*SkillMetadata, error) {- preloaded, err := m.loader.DiscoverSkills()- if err != nil {- return nil, err- }- return m.mergeWithTenantSkills(preloaded)-}--// mergeWithTenantSkills overlays the installed skills on a freshly discovered-// preloaded set.-func (m *Manager) mergeWithTenantSkills(preloaded []*SkillMetadata) ([]*SkillMetadata, error) {- if m.tenantSource == nil {- return preloaded, nil- }- tenant, err := m.tenantSource.DiscoverSkills()- if err != nil {- return nil, err- }- return mergeSkillMetadata(preloaded, tenant), nil-}--// mergeSkillMetadata overlays the installed skills on the preloaded ones,-// keeping the preloaded ordering for the names both sources carry so the-// system prompt does not reshuffle when a skill is installed.-func mergeSkillMetadata(preloaded, tenant []*SkillMetadata) []*SkillMetadata {- byName := make(map[string]*SkillMetadata, len(tenant))- for _, meta := range tenant {- if meta != nil {- byName[meta.Name] = meta- }- }- merged := make([]*SkillMetadata, 0, len(preloaded)+len(tenant))- overridden := make(map[string]bool, len(tenant))- for _, meta := range preloaded {- if meta == nil {- continue- }- if installed, ok := byName[meta.Name]; ok {- merged = append(merged, installed)- overridden[meta.Name] = true- continue- }- merged = append(merged, meta)- }- for _, meta := range tenant {- if meta != nil && !overridden[meta.Name] {- merged = append(merged, meta)- }+ if m.tenantSource != nil {+ return m.tenantSource.DiscoverSkills()}- return merged+ return m.loader.Reload()}// Initialize discovers all skills and caches their metadata@@ -491,11 +447,7 @@ func (m *Manager) Reload(ctx context.Context) error {return nil}- preloaded, err := m.loader.Reload()- if err != nil {- return err- }- metadata, err := m.mergeWithTenantSkills(preloaded)+ metadata, err := m.discoverAllSkills()if err != nil {return err}diff --git a/internal/agent/skills/tenant_source_test.go b/internal/agent/skills/tenant_source_test.goindex 5463dbd94..449d5e22c 100644--- a/internal/agent/skills/tenant_source_test.go+++ b/internal/agent/skills/tenant_source_test.go@@ -188,8 +188,8 @@ func TestTenantSkillSourceReportsAMissingBundleWithoutBlockingExecution(t *testirequire.Equal(t, "/opt/weknora/tenant/skills/pdf/scripts/extract.py", remote)}-func TestManagerPrefersTheTenantSkillOverASameNamedPreloadedOne(t *testing.T) {- dir := preloadedSkillDir(t, "pdf", "preloaded description")+func TestManagerIgnoresPreloadedSkillsWhenTenantSourceIsAttached(t *testing.T) {+ dir := preloadedSkillDir(t, "document-analyzer", "preloaded description")mgr := NewManager(&ManagerConfig{SkillDirs: []string{dir}, Enabled: true}, nil)mgr.WithTenantSource(NewTenantSkillSource([]*types.TenantSkillEntity{{@@ -209,13 +209,17 @@ func TestManagerPrefersTheTenantSkillOverASameNamedPreloadedOne(t *testing.T) {byName[meta.Name] = meta}require.Len(t, byName, 2)- require.Equal(t, "tenant description", byName["pdf"].Description,- "the tenant's own install is what the sandbox image actually carries")+ require.NotContains(t, byName, "document-analyzer",+ "host preloaded skills are not in the sandbox image")+ require.Equal(t, "tenant description", byName["pdf"].Description)require.Equal(t, "tenant only", byName["csv"].Description)skill, err := mgr.LoadSkill(context.Background(), "pdf")require.NoError(t, err)require.Equal(t, "tenant body", skill.Instructions)++ _, err = mgr.LoadSkill(context.Background(), "document-analyzer")+ require.Error(t, err, "a host-only skill must not be readable once the image is the source")}func TestManagerRunsATenantSkillFromTheImageWithoutUploading(t *testing.T) {@@ -246,13 +250,10 @@ func TestManagerRunsATenantSkillFromTheImageWithoutUploading(t *testing.T) {// Preloaded skills keep uploading from the host and keep running in their own// directory; the tenant source must not change that path at all.-func TestManagerKeepsPreloadedSkillExecutionUnchanged(t *testing.T) {+func TestManagerKeepsPreloadedSkillExecutionWhenNoTenantSource(t *testing.T) {dir := preloadedSkillDir(t, "pdf", "preloaded description")sandboxMgr := &recordingSandboxManager{}mgr := NewManager(&ManagerConfig{SkillDirs: []string{dir}, Enabled: true}, sandboxMgr)- mgr.WithTenantSource(NewTenantSkillSource([]*types.TenantSkillEntity{{- ID: "sk-1", Name: "csv", Status: types.SkillStatusReady, Enabled: true,- }}, nil))require.NoError(t, mgr.Initialize(context.Background()))_, err := mgr.ExecuteScript(context.Background(), "pdf", "scripts/run.py", nil, "")diff --git a/internal/application/service/agent_service.go b/internal/application/service/agent_service.goindex 1bc648120..5cc2a3dd3 100644--- a/internal/application/service/agent_service.go+++ b/internal/application/service/agent_service.go@@ -237,20 +237,18 @@ func (s *agentService) CreateAgentEngine(}}- skillsEnabledWithDirs := config.SkillsEnabled && len(config.SkillDirs) > 0- // Initialize the skills/sandbox manager when skills are configured, or for- // the skill installer, which keeps skills off yet needs the sandbox shell.- // The second disjunct is deliberately NOT "the config lists a sandbox- // tool": shell_exec is a user-selectable entry in the tool picker, so that- // rule would hand a live sandbox shell to every stored agent record that- // already lists it. Install mode is settable only through- // EnableSkillInstallMode, so only the built-in installer passes here and- // every other agent keeps exactly its previous behaviour.- if skillsEnabledWithDirs || config.SkillInstallMode() {+ // TenantSkills is the sandbox image. SkillDirs is the host+ // skills/preloaded tree and is no longer filled on the QA path; it+ // remains so tests (and any caller that still points at a host+ // directory) can construct a manager. Install mode initializes for+ // the shell without hanging a skills manager on the engine.+ offerSkills := config.SkillsEnabled &&+ (len(config.SkillDirs) > 0 || len(config.TenantSkills) > 0)+ if offerSkills || config.SkillInstallMode() {skillsManager, err := s.initializeSkillsManager(ctx, sessionID, config, toolRegistry)if err != nil {logger.Warnf(ctx, "Failed to initialize skills manager: %v", err)- } else if skillsEnabledWithDirs && skillsManager != nil {+ } else if offerSkills && skillsManager != nil {engine.SetSkillsManager(skillsManager)logger.Infof(ctx, "Skills manager initialized with %d skills",len(skillsManager.GetAllMetadata()))@@ -838,6 +836,14 @@ func (s *agentService) registerTools(case tools.ToolWikiDeletePage:toolToRegister = tools.NewWikiDeletePageTool(s.wikiPageService, wikiKBIDs, wikiRoutes)+ case tools.ToolShellExec, tools.ToolReadSkill, tools.ToolExecuteSkillScript,+ tools.ToolListSandboxFiles, tools.ToolReadSandboxFile:+ // Bound to the resolved sandbox manager in initializeSkillsManager+ // / registerSandboxShellTool. Listing them here would warn+ // "Unknown tool: shell_exec" on every skill install, then register+ // the real tool a few lines later.+ continue+default:logger.Warnf(ctx, "Unknown tool: %s", toolName)}@@ -1178,6 +1184,11 @@ func (s *agentService) resolvePinnedSkillInfos(config *types.AgentConfig) []*age}}}+ for _, row := range config.TenantSkills {+ if row != nil && row.Name != "" {+ descByName[row.Name] = row.Description+ }+ }result := make([]*agent.PinnedSkillInfo, 0, len(config.PinnedSkillNames))for _, name := range config.PinnedSkillNames {diff --git a/internal/application/service/agent_service_test.go b/internal/application/service/agent_service_test.goindex 603e06979..a0e8ca4e7 100644--- a/internal/application/service/agent_service_test.go+++ b/internal/application/service/agent_service_test.go@@ -3,6 +3,7 @@ package serviceimport ("context""errors"+ "os""path/filepath""testing""time"@@ -253,6 +254,42 @@ func TestCreateAgentEngineOpensSandboxToolsOnlyForInstallMode(t *testing.T) {require.True(t, toolOffered(chatModel.lastToolNames, tools.ToolExecuteSkillScript))require.NotNil(t, engine.(*agent.AgentEngine).GetSkillsManager())})++ t.Run("skills enabled with tenant skills and no host dirs still offers skill tools", func(t *testing.T) {+ chatModel := &fakeAgentChatModel{}+ svc := &agentService{+ sandboxResolver: stubSandboxResolver{+ mgr: &capableManager{+ typ: sandbox.SandboxTypeCube,+ shell: &stubShellExecutor{},+ files: stubSessionFileStore{},+ },+ },+ }++ engine, err := svc.CreateAgentEngine(ctx, &types.AgentConfig{+ SandboxConfigID: "cfg-remote",+ SkillsEnabled: true,+ TenantSkills: []*types.TenantSkillEntity{{+ ID: "sk-1", TenantID: 7, SandboxConfigID: "cfg-remote",+ Name: "pdf-tools", Description: "PDF helpers",+ Status: types.SkillStatusReady, Enabled: true,+ }},+ }, chatModel, nil, nil, "sess-1", "msg-1")++ require.NoError(t, err)+ _, err = engine.Execute(ctx, "sess-1", "msg-1", "hello", nil)+ require.NoError(t, err)+ require.True(t, toolOffered(chatModel.lastToolNames, tools.ToolReadSkill))+ require.True(t, toolOffered(chatModel.lastToolNames, tools.ToolExecuteSkillScript))+ mgr := engine.(*agent.AgentEngine).GetSkillsManager()+ require.NotNil(t, mgr)+ var names []string+ for _, meta := range mgr.GetAllMetadata() {+ names = append(names, meta.Name)+ }+ require.Equal(t, []string{"pdf-tools"}, names)+ })}func TestSkillToolsFollowSkillsEnabled(t *testing.T) {@@ -321,6 +358,47 @@ func TestSkillsManagerOffersTheInjectedInstalledSkills(t *testing.T) {return names}+ t.Run("injected rows are offered without a host skill directory", func(t *testing.T) {+ mgr, err := newSvc().initializeSkillsManager(ctx, "sess-1", &types.AgentConfig{+ SandboxConfigID: "cfg-remote",+ SkillsEnabled: true,+ TenantSkills: []*types.TenantSkillEntity{{+ ID: "sk-1", TenantID: 7, SandboxConfigID: "cfg-remote",+ Name: "pdf-tools", Description: "PDF helpers",+ Status: types.SkillStatusReady, Enabled: true,+ }},+ }, tools.NewToolRegistry())++ require.NoError(t, err)+ require.Equal(t, []string{"pdf-tools"}, skillNamesOf(mgr))+ })++ t.Run("host preloaded skills are not offered beside the sandbox image", func(t *testing.T) {+ dir := t.TempDir()+ skillDir := filepath.Join(dir, "document-analyzer")+ require.NoError(t, os.MkdirAll(skillDir, 0o755))+ require.NoError(t, os.WriteFile(+ filepath.Join(skillDir, "SKILL.md"),+ []byte("---\nname: document-analyzer\ndescription: old host copy\n---\n"),+ 0o644,+ ))++ mgr, err := newSvc().initializeSkillsManager(ctx, "sess-1", &types.AgentConfig{+ SandboxConfigID: "cfg-remote",+ SkillsEnabled: true,+ SkillDirs: []string{dir},+ TenantSkills: []*types.TenantSkillEntity{{+ ID: "sk-1", TenantID: 7, SandboxConfigID: "cfg-remote",+ Name: "pdf-tools", Description: "PDF helpers",+ Status: types.SkillStatusReady, Enabled: true,+ }},+ }, tools.NewToolRegistry())++ require.NoError(t, err)+ require.Equal(t, []string{"pdf-tools"}, skillNamesOf(mgr),+ "the host skills/preloaded tree is not what the sandbox image carries")+ })+t.Run("injected rows are offered", func(t *testing.T) {mgr, err := newSvc().initializeSkillsManager(ctx, "sess-1", &types.AgentConfig{SandboxConfigID: "cfg-remote",diff --git a/internal/application/service/session_agent_qa.go b/internal/application/service/session_agent_qa.goindex 4044a9b5b..33cb9392d 100644--- a/internal/application/service/session_agent_qa.go+++ b/internal/application/service/session_agent_qa.go@@ -566,11 +566,10 @@ func dedupPreservingOrder(values []string) []string {return result}-// configureSkillsFromAgent configures skills settings in AgentConfig based on CustomAgentConfig-// Returns the skill directories and allowed skills based on the selection mode:-// - "all": uses all preloaded skills-// - "selected": uses the explicitly selected skills-// - "none" or "": skills are disabled+// configureSkillsFromAgent turns the agent's skill picker into runtime flags.+// The skills themselves come from the sandbox image (TenantSkills), not from+// the deployment's skills/preloaded directory — that host copy is not what+// execute_skill_script would find inside the sandbox.func (s *sessionService) configureSkillsFromAgent(ctx context.Context,agentConfig *types.AgentConfig,@@ -580,19 +579,14 @@ func (s *sessionService) configureSkillsFromAgent(return}agentConfig.SandboxConfigID = customAgent.Config.SandboxConfigID- dir := getPreloadedSkillsDir()switch customAgent.Config.SkillsSelectionMode {case "all":- // Enable all preloaded skillsagentConfig.SkillsEnabled = true- agentConfig.SkillDirs = []string{dir}- agentConfig.AllowedSkills = nil // Empty means all skills allowed- logger.Infof(ctx, "SkillsSelectionMode=all: enabled all preloaded skills")+ agentConfig.AllowedSkills = nil+ logger.Infof(ctx, "SkillsSelectionMode=all: using installed sandbox skills")case "selected":- // Enable only selected skillsif len(customAgent.Config.SelectedSkills) > 0 {agentConfig.SkillsEnabled = true- agentConfig.SkillDirs = []string{dir}agentConfig.AllowedSkills = customAgent.Config.SelectedSkillslogger.Infof(ctx, "SkillsSelectionMode=selected: enabled %d selected skills: %v",len(customAgent.Config.SelectedSkills), customAgent.Config.SelectedSkills)@@ -601,11 +595,9 @@ func (s *sessionService) configureSkillsFromAgent(logger.Infof(ctx, "SkillsSelectionMode=selected but no skills selected: skills disabled")}case "none", "":- // Skills disabledagentConfig.SkillsEnabled = falselogger.Infof(ctx, "SkillsSelectionMode=%s: skills disabled", customAgent.Config.SkillsSelectionMode)default:- // Unknown mode, disable skillsagentConfig.SkillsEnabled = falselogger.Warnf(ctx, "Unknown SkillsSelectionMode=%s: skills disabled", customAgent.Config.SkillsSelectionMode)}diff --git a/internal/application/service/session_agent_qa_scope_test.go b/internal/application/service/session_agent_qa_scope_test.goindex 5ebb320af..82d078964 100644--- a/internal/application/service/session_agent_qa_scope_test.go+++ b/internal/application/service/session_agent_qa_scope_test.go@@ -98,3 +98,18 @@ func TestApplyPerRequestSkillScope_NoneIgnores(t *testing.T) {applyPerRequestSkillScope(context.Background(), cfg, "none", []string{"a"})assert.Empty(t, cfg.PinnedSkillNames)}++func TestConfigureSkillsFromAgentDoesNotLoadHostPreloadedDir(t *testing.T) {+ svc := &sessionService{}+ cfg := &types.AgentConfig{}+ svc.configureSkillsFromAgent(context.Background(), cfg, &types.CustomAgent{+ Config: types.CustomAgentConfig{+ SandboxConfigID: "cfg-1",+ SkillsSelectionMode: "all",+ },+ })+ assert.True(t, cfg.SkillsEnabled)+ assert.Equal(t, "cfg-1", cfg.SandboxConfigID)+ assert.Empty(t, cfg.SkillDirs,+ "the host skills/preloaded tree is not what the sandbox image carries")+}diff --git a/internal/application/service/tenant_skill_install.go b/internal/application/service/tenant_skill_install.goindex 83b24929f..79370627c 100644--- a/internal/application/service/tenant_skill_install.go+++ b/internal/application/service/tenant_skill_install.go@@ -1,6 +1,8 @@package serviceimport (+ "archive/tar"+ "bytes""context""encoding/json""errors"@@ -36,6 +38,11 @@ const (// still missing is the row that says so.readySkillWriteAttempts = 3readySkillWriteDelay = 100 * time.Millisecond++ // skillSeedArchivePath is the single remote write used to land a skill's+ // files. Writing each file with MakeDir+WriteFile is two round trips per+ // entry, which is why a 50-file skill crawled through "seeding 12/56".+ skillSeedArchivePath = sandbox.SkillsImageRoot + "/.weknora-seed.tar")// InstallSkill validates an uploaded archive, records it, and kicks off the@@ -270,13 +277,30 @@ func (s *TenantSkillService) runInstall(if err := s.resetSkillDir(ctx, mgr, sess.ID, skillDir); err != nil {return err}++ // Locators must land before the file seed. A large skill is copied file by+ // file over the sandbox API and can take minutes; the console attaches to+ // the transcript as soon as the directory is ready, not after that copy.+ transcript, prompt := s.beginInstallTranscript(ctx, tenantID, skillID, sess, mgr, skillDir, bundle)++ fileCount := 0+ if bundle != nil {+ fileCount = len(bundle.Files)+ }+ if fileCount > 0 {+ logger.Infof(ctx, "[skill] seeding %d files for %s as one archive", fileCount, skillID)+ s.publishProgress(ctx, tenantID, configID, skillID, SkillProgress{+ Percent: 28, Stage: "seeding",+ Log: fmt.Sprintf("seeding %d files", fileCount),+ })+ }if err := s.seedSkillFiles(ctx, mgr, sess.ID, skillDir, bundle); err != nil {return err}s.publishProgress(ctx, tenantID, configID, skillID, SkillProgress{Percent: 35, Stage: "seeded"})// 3. Let the installer agent install dependencies.- if err := s.driveInstallerAgent(ctx, tenantID, skillID, sess, mgr, skillDir, bundle); err != nil {+ if err := s.driveInstallerAgent(ctx, tenantID, skillID, sess, transcript, prompt); err != nil {return err}s.publishProgress(ctx, tenantID, configID, skillID, SkillProgress{Percent: 80, Stage: "agent_done"})@@ -495,33 +519,112 @@ func guardSkillDir(skillDir string) error {// server-side rather than asking the agent to unpack keeps the source of truth// byte-identical to what was uploaded. Provisioning the directory is// runInstall's step 2, not this function's job.+//+// The files travel as one tar: each remote WriteFile is a MakeDir plus an+// upload, and a skill with dozens of files was spending minutes on that+// round-trip tax. Extracting inside the sandbox is one local untar.func (s *TenantSkillService) seedSkillFiles(ctx context.Context, mgr sandbox.Manager, sessionID, skillDir string, bundle *SkillBundle,) error {+ if bundle == nil || len(bundle.Files) == 0 {+ return nil+ }store, err := installFileStore(mgr)if err != nil {return err}- for rel, content := range bundle.Files {- target := path.Join(skillDir, rel)- if err := store.WriteSessionFile(ctx, sessionID, target, content); err != nil {- return fmt.Errorf("seed %s: %w", target, err)- }+ archive, err := packSkillTar(bundle)+ if err != nil {+ return err+ }+ if err := store.WriteSessionFile(ctx, sessionID, skillSeedArchivePath, archive); err != nil {+ return fmt.Errorf("seed skill archive: %w", err)+ }+ if _, err := s.execInstall(ctx, mgr, sessionID, seedExtractCommand(skillDir)); err != nil {+ return fmt.Errorf("extract skill archive: %w", err)}return nil}+func seedExtractCommand(skillDir string) string {+ tarPath := sandbox.ShellQuote(skillSeedArchivePath)+ dir := sandbox.ShellQuote(skillDir)+ return fmt.Sprintf("tar -xf %s -C %s && rm -f %s", tarPath, dir, tarPath)+}++func packSkillTar(bundle *SkillBundle) ([]byte, error) {+ if bundle == nil {+ return nil, nil+ }+ names := make([]string, 0, len(bundle.Files))+ for rel := range bundle.Files {+ names = append(names, rel)+ }+ sort.Strings(names)++ var buf bytes.Buffer+ tw := tar.NewWriter(&buf)+ for _, rel := range names {+ name := path.Clean(rel)+ if name == "." || name == ".." || strings.HasPrefix(name, "../") || path.IsAbs(name) {+ return nil, fmt.Errorf("skill file %q escapes the archive root", rel)+ }+ content := bundle.Files[rel]+ if err := tw.WriteHeader(&tar.Header{+ Name: name,+ Mode: 0o644,+ Size: int64(len(content)),+ }); err != nil {+ return nil, err+ }+ if _, err := tw.Write(content); err != nil {+ return nil, err+ }+ }+ if err := tw.Close(); err != nil {+ return nil, err+ }+ return buf.Bytes(), nil+}++// beginInstallTranscript writes the locators and opening prompt after the+// skill directory is reset, so a console that opens during the file seed+// finds something to follow instead of 404-polling for minutes.+func (s *TenantSkillService) beginInstallTranscript(+ ctx context.Context, tenantID uint64, skillID string,+ sess *types.Session, mgr sandbox.Manager, skillDir string, bundle *SkillBundle,+) (*installTranscript, string) {+ assistantMessageID := uuid.NewString()+ prompt := buildInstallPrompt(skillDir, bundle, s.probeUv(ctx, mgr, sess.ID))+ transcript := newInstallTranscript(ctx, event.NewEventBus(), s.streams, s.messages, sess.ID, assistantMessageID)+ if err := transcript.Create(ctx, prompt); err != nil {+ logger.Warnf(ctx, "[skill] seed install transcript for %s failed: %v", skillID, err)+ }+ transcript.Subscribe()+ if err := s.updateSkillFields(ctx, tenantID, sess.SandboxConfigID, skillID,+ func(e *types.TenantSkillEntity) {+ e.InstallSessionID = sess.ID+ e.InstallMessageID = assistantMessageID+ }); err != nil {+ logger.Warnf(ctx, "[skill] record transcript locators for %s failed: %v", skillID, err)+ }+ return transcript, prompt+}+// driveInstallerAgent runs one installer conversation. It calls the engine// directly instead of going through sessionService.AgentQA, because AgentQA// swallows engine failures (it emits an error event and returns nil) and we// need a reliable signal before switching the image.func (s *TenantSkillService) driveInstallerAgent(ctx context.Context, tenantID uint64, skillID string, sess *types.Session,- mgr sandbox.Manager, skillDir string, bundle *SkillBundle,+ transcript *installTranscript, prompt string,) error {if s.installerAgents == nil {return errors.New("custom agent service is not configured")}+ if transcript == nil {+ return errors.New("install transcript was not seeded")+ }// The record is tenant-writable: updateBuiltinAgent lets a tenant persist a// Config for any built-in ID, this one included. It is therefore read for// the model choice only. What the root shell is told to do comes from the@@ -537,30 +640,8 @@ func (s *TenantSkillService) driveInstallerAgent(return err}- bus := event.NewEventBus()- assistantMessageID := uuid.NewString()- prompt := buildInstallPrompt(skillDir, bundle, s.probeUv(ctx, mgr, sess.ID))-- // The transcript is set up before the engine so a console that attaches- // while the install is still running finds a message to stream into. Its- // failures are logged rather than returned: an unreadable transcript is a- // worse outcome than no transcript, but neither is a reason to refuse an- // otherwise good install.- transcript := newInstallTranscript(ctx, bus, s.streams, s.messages, sess.ID, assistantMessageID)- if err := transcript.Create(ctx, prompt); err != nil {- logger.Warnf(ctx, "[skill] seed install transcript for %s failed: %v", skillID, err)- }- transcript.Subscribe()- if err := s.updateSkillFields(ctx, tenantID, sess.SandboxConfigID, skillID,- func(e *types.TenantSkillEntity) {- e.InstallSessionID = sess.ID- e.InstallMessageID = assistantMessageID- }); err != nil {- logger.Warnf(ctx, "[skill] record transcript locators for %s failed: %v", skillID, err)- }-engine, err := s.agents.CreateAgentEngine(- ctx, agentConfig, chatModel, nil, bus, sess.ID, assistantMessageID,+ ctx, agentConfig, chatModel, nil, transcript.bus, sess.ID, transcript.assistantMessageID,)if err != nil {runErr := fmt.Errorf("create installer engine: %w", err)@@ -568,7 +649,7 @@ func (s *TenantSkillService) driveInstallerAgent(return runErr}- state, err := engine.Execute(ctx, sess.ID, assistantMessageID, prompt, nil)+ state, err := engine.Execute(ctx, sess.ID, transcript.assistantMessageID, prompt, nil)runErr := errif runErr == nil && (state == nil || !state.IsComplete) {runErr = errors.New("installer agent stopped without completing")diff --git a/internal/application/service/tenant_skill_install_test.go b/internal/application/service/tenant_skill_install_test.goindex e8c03a41d..a472fbbd9 100644--- a/internal/application/service/tenant_skill_install_test.go+++ b/internal/application/service/tenant_skill_install_test.go@@ -1,12 +1,15 @@package serviceimport (+ "archive/tar"+ "bytes""context""encoding/json""errors""fmt""io""mime/multipart"+ "path""path/filepath""sort""strings"@@ -79,6 +82,7 @@ func TestRunInstallIssuesExactlyTheseCommands(t *testing.T) {require.Equal(t, []string{installPrepareCommand,"uv --version",+ seedExtractCommand(installSkillDir),"chmod -R 555 " + installSkillDir,"chown -R root:root " + installSkillDir,"test -f " + installSkillDir + "/SKILL.md",@@ -1024,6 +1028,54 @@ func TestRunInstallPublishesTranscriptLocatorsBeforeTheAgentRuns(t *testing.T) {require.NotEmpty(t, atExecute.InstallMessageID)}+func TestRunInstallPublishesTranscriptLocatorsBeforeSeedingFiles(t *testing.T) {+ fx := newInstallFixture(t)++ var atSeed *types.TenantSkillEntity+ fx.beforeSeed = func() {+ skill, err := fx.skillRepo.GetSkill(context.Background(), 7, "cfg-1", "sk-1")+ require.NoError(t, err)+ copied := *skill+ atSeed = &copied+ }++ require.NoError(t, fx.svc.runInstall(ctxWithTenant(7), 7, "cfg-1", "sk-1", fx.bundle))++ require.NotNil(t, atSeed, "files were seeded without a hook")+ require.NotEmpty(t, atSeed.InstallSessionID)+ require.NotEmpty(t, atSeed.InstallMessageID)+}++func TestPackSkillTarRoundTrip(t *testing.T) {+ bundle := &SkillBundle{Files: map[string][]byte{+ "SKILL.md": []byte("name: x"),+ "scripts/extract.py": []byte("print(1)\n"),+ }}+ raw, err := packSkillTar(bundle)+ require.NoError(t, err)++ got := map[string][]byte{}+ tr := tar.NewReader(bytes.NewReader(raw))+ for {+ hdr, err := tr.Next()+ if err == io.EOF {+ break+ }+ require.NoError(t, err)+ content, err := io.ReadAll(tr)+ require.NoError(t, err)+ got[hdr.Name] = content+ }+ require.Equal(t, bundle.Files, got)+}++func TestPackSkillTarRejectsEscapingNames(t *testing.T) {+ _, err := packSkillTar(&SkillBundle{Files: map[string][]byte{+ "../etc/passwd": []byte("x"),+ }})+ require.Error(t, err)+}+// Maintenance sessions are excluded from the console by their description, and// scoped to the admin who started the install by their owner. Both are written// at creation time; neither has a backfill.@@ -1107,6 +1159,9 @@ type installFixture struct {// beforeExecute runs at the moment the engine would start, so a test can// observe the state an attaching console would see mid-install.beforeExecute func()+ // beforeSeed runs on the first image file write, so a test can prove the+ // transcript locators landed before the minutes-long copy begins.+ beforeSeed func()// staleMarks records every InvalidateConfigSandboxes call, so a test can// state which config was marked rather than only that something was.staleMarks []staleMark@@ -1661,11 +1716,59 @@ func (m *installSandboxManager) WriteSessionFile(return nil}if !containsEvent(m.fx.events, "seed-files") {+ if m.fx.beforeSeed != nil {+ m.fx.beforeSeed()+ }m.fx.record("seed-files")}return nil}+func (m *installSandboxManager) extractSeedArchive(command string) {+ archive, ok := m.writeContents[skillSeedArchivePath]+ if !ok {+ return+ }+ skillDir := installSkillDir+ if _, after, found := strings.Cut(command, " -C "); found {+ dir, _, _ := strings.Cut(strings.TrimSpace(after), " ")+ if dir != "" {+ skillDir = dir+ }+ }+ tr := tar.NewReader(bytes.NewReader(archive))+ for {+ hdr, err := tr.Next()+ if err == io.EOF {+ break+ }+ if err != nil {+ return+ }+ if hdr.Typeflag != tar.TypeReg && hdr.Typeflag != 0 {+ continue+ }+ content, err := io.ReadAll(tr)+ if err != nil {+ return+ }+ dest := path.Join(skillDir, hdr.Name)+ m.writes = append(m.writes, dest)+ if m.writeContents == nil {+ m.writeContents = map[string][]byte{}+ }+ m.writeContents[dest] = content+ }+ delete(m.writeContents, skillSeedArchivePath)+ kept := m.writes[:0]+ for _, w := range m.writes {+ if w != skillSeedArchivePath {+ kept = append(kept, w)+ }+ }+ m.writes = kept+}+func (m *installSandboxManager) RemoveSessionInputPath(context.Context, string, string) error {return nil}@@ -1696,6 +1799,8 @@ func (m *installSandboxManager) ExecShellCommandWithOptions(switch {case command == installPrepareCommand:m.fx.record("prepare-skill-dir")+ case strings.HasPrefix(command, "tar -xf "):+ m.extractSeedArchive(command)case strings.HasPrefix(command, "test -f "):if !m.structureSeen {m.fx.record("verify-structure")diff --git a/internal/handler/sandbox_skill.go b/internal/handler/sandbox_skill.goindex 424afe85f..a7f25fbbf 100644--- a/internal/handler/sandbox_skill.go+++ b/internal/handler/sandbox_skill.go@@ -567,6 +567,7 @@ func (h *SandboxSkillHandler) InstallEvents(c *gin.Context) {// @Param id path string true "Sandbox config ID"// @Param skillId path string true "Skill ID"// @Success 200 {string} string "SSE stream of transcript events"+// @Success 204 {string} string "Install is still preparing; retry once locators exist"// @Failure 401 {object} map[string]interface{} "Unauthorized"// @Failure 404 {object} apperrors.AppError "Skill or transcript not found"// @Security Bearer@@ -589,6 +590,13 @@ func (h *SandboxSkillHandler) InstallTranscript(c *gin.Context) {}sessionID, messageID := skill.InstallSessionID, skill.InstallMessageIDif sessionID == "" || messageID == "" {+ // The skill row exists the moment the upload is accepted; locators+ // are written only after the installer sandbox is up. A 404 here is+ // "not yet", not "gone", and the access log would WARN on every poll.+ if skill.Status == types.SkillStatusInstalling {+ c.Status(http.StatusNoContent)+ return+ }_ = c.Error(apperrors.NewNotFoundError("this skill has no install transcript"))return}diff --git a/internal/handler/sandbox_skill_test.go b/internal/handler/sandbox_skill_test.goindex 1f18b9349..dd911b258 100644--- a/internal/handler/sandbox_skill_test.go+++ b/internal/handler/sandbox_skill_test.go@@ -887,6 +887,19 @@ func TestSandboxSkillTranscriptWithoutLocatorsReturns404(t *testing.T) {require.Equal(t, http.StatusNotFound, w.Code, "body=%s", w.Body.String())}+func TestSandboxSkillTranscriptWhileInstallIsPreparingReturns204(t *testing.T) {+ svc := &fakeSandboxSkillService{skills: map[string]*types.TenantSkillEntity{+ "skill-1": {ID: "skill-1", SandboxConfigID: "cfg-a", Status: types.SkillStatusInstalling},+ }}+ router := newSkillTestRouter(NewSandboxSkillHandler(svc, &transcriptStreamManager{}))++ w := httptest.NewRecorder()+ router.ServeHTTP(w, transcriptRequest("cfg-a", "skill-1"))++ require.Equal(t, http.StatusNoContent, w.Code, "body=%s", w.Body.String())+ require.NotContains(t, w.Header().Get("Content-Type"), "event-stream")+}+// The skill lookup is this endpoint's authorization: an install transcript can// hold command output from another workspace's image build.func TestSandboxSkillTranscriptOfAnotherConfigReturns404(t *testing.T) {