diff --git a/packages/cli/src/acp-integration/acpAgent.ts b/packages/cli/src/acp-integration/acpAgent.ts index 392d0247573..59a2ddecf26 100644 --- a/packages/cli/src/acp-integration/acpAgent.ts +++ b/packages/cli/src/acp-integration/acpAgent.ts @@ -157,6 +157,7 @@ import { loadCliConfig, } from '../config/config.js'; import { extractRememberErrorCode } from '../serve/workspace-remember-errors.js'; +import { mapSkillConfigToStatus } from '../serve/workspace-skills-mapping.js'; import { Session, buildAvailableCommandsSnapshot } from './session/Session.js'; import { buildSessionTasksStatus } from './session/tasksSnapshot.js'; import { HistoryReplayer } from './session/HistoryReplayer.js'; @@ -216,7 +217,6 @@ import { type ServeWorkspaceProviderModel, type ServeWorkspaceProviderStatus, type ServeWorkspaceProvidersStatus, - type ServeWorkspaceSkillStatus, type ServeWorkspaceSkillsStatus, type ServeWorkspaceToolStatus, type ServeWorkspaceToolsStatus, @@ -3896,22 +3896,7 @@ class QwenAgent implements Agent { v: STATUS_SCHEMA_VERSION, workspaceCwd: this.workspaceCwd(config), initialized: true, - skills: skills.map((skill): ServeWorkspaceSkillStatus => { - const modelInvocable = skill.disableModelInvocation !== true; - return { - kind: 'skill', - status: modelInvocable ? 'ok' : 'disabled', - name: skill.name, - description: skill.description, - level: skill.level, - modelInvocable, - ...(skill.argumentHint ? { argumentHint: skill.argumentHint } : {}), - ...(skill.model ? { model: skill.model } : {}), - ...(skill.extensionName - ? { extensionName: skill.extensionName } - : {}), - }; - }), + skills: skills.map(mapSkillConfigToStatus), }; } catch (error) { return { diff --git a/packages/cli/src/serve/run-qwen-serve.ts b/packages/cli/src/serve/run-qwen-serve.ts index ab2d332ff16..1c529294ce2 100644 --- a/packages/cli/src/serve/run-qwen-serve.ts +++ b/packages/cli/src/serve/run-qwen-serve.ts @@ -692,6 +692,7 @@ async function loadServeRuntimeModules() { workspaceTypesModule, daemonStatusProviderModule, workspaceProvidersStatusModule, + workspaceSkillsStatusModule, ] = await Promise.all([ import('./server.js'), import('@qwen-code/acp-bridge/bridge'), @@ -700,6 +701,7 @@ async function loadServeRuntimeModules() { import('./workspace-service/types.js'), import('./daemon-status-provider.js'), import('./workspace-providers-status.js'), + import('./workspace-skills-status.js'), ]); return { createServeApp: serverModule.createServeApp, @@ -714,6 +716,8 @@ async function loadServeRuntimeModules() { daemonStatusProviderModule.createDaemonStatusProvider, createWorkspaceProvidersStatusProvider: workspaceProvidersStatusModule.createWorkspaceProvidersStatusProvider, + createWorkspaceSkillsStatusProvider: + workspaceSkillsStatusModule.createWorkspaceSkillsStatusProvider, }; } @@ -2031,6 +2035,8 @@ export async function runQwenServe( const statusProvider = runtime.createDaemonStatusProvider(); const workspaceProvidersStatusProvider = runtime.createWorkspaceProvidersStatusProvider(); + const workspaceSkillsStatusProvider = + runtime.createWorkspaceSkillsStatusProvider(); // Reverse tool channel (issue #5626, Phase 2). ONE sender registry shared // between the bridge (which answers the ACP child's `client_mcp/message` // ext-method via `clientMcpSender`) and the WS provider in `createServeApp` @@ -2161,6 +2167,7 @@ export async function runQwenServe( contextFilename: contextFilenameForInit ?? 'QWEN.md', statusProvider, workspaceProvidersStatusProvider, + workspaceSkillsStatusProvider, isChannelLive: () => bridge.isChannelLive(), persistDisabledTools: persistDisabledToolsFn, persistSetting: persistSettingFn, diff --git a/packages/cli/src/serve/server.ts b/packages/cli/src/serve/server.ts index ef3aef0af33..058dae08fcd 100644 --- a/packages/cli/src/serve/server.ts +++ b/packages/cli/src/serve/server.ts @@ -25,6 +25,7 @@ import type { DaemonStatusProvider } from '@qwen-code/acp-bridge'; import { createBridgeFileSystemAdapter } from './bridge-file-system-adapter.js'; import { createDaemonStatusProvider } from './daemon-status-provider.js'; import { createWorkspaceProvidersStatusProvider } from './workspace-providers-status.js'; +import { createWorkspaceSkillsStatusProvider } from './workspace-skills-status.js'; import { mountAcpHttp, type AcpHttpHandle } from './acp-http/index.js'; import { createVoiceWsConnectionHandler } from './voice/voice-ws.js'; import { @@ -411,6 +412,7 @@ export function createServeApp( statusProvider, workspaceProvidersStatusProvider: createWorkspaceProvidersStatusProvider(), + workspaceSkillsStatusProvider: createWorkspaceSkillsStatusProvider(), isChannelLive: () => bridge.isChannelLive(), persistDisabledTools: deps.persistDisabledTools ?? diff --git a/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts b/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts index 935f09980ac..e5921dcc26e 100644 --- a/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts +++ b/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts @@ -642,6 +642,248 @@ describe('createDaemonWorkspaceService', () => { expect(result.skills).toEqual([]); }); + it('getWorkspaceSkillsStatus replays the last live child status when the channel is idle', async () => { + const liveStatus = { + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [ + { + kind: 'skill', + status: 'ok', + name: 'review', + description: 'Review changed code', + level: 'bundled', + modelInvocable: true, + }, + ], + }; + let channelLive = true; + const queryWorkspaceStatus = vi + .fn() + .mockImplementation((_m: string, idle: () => unknown) => + Promise.resolve(channelLive ? liveStatus : idle()), + ); + const svc = createDaemonWorkspaceService( + makeDeps({ queryWorkspaceStatus, boundWorkspace: '/ws' }), + ); + + // Channel live: authoritative skills from the ACP child, cached. + const first = await svc.getWorkspaceSkillsStatus(makeCtx()); + expect(first.initialized).toBe(true); + expect(first.skills.map((s) => s.name)).toEqual(['review']); + + // Channel reaped: queryWorkspaceStatus falls back to the empty idle + // placeholder, but the facade replays the last live status so + // skill-backed slash commands (e.g. /review) keep autocompleting. + channelLive = false; + const second = await svc.getWorkspaceSkillsStatus(makeCtx()); + expect(second.initialized).toBe(true); + expect(second.skills.map((s) => s.name)).toEqual(['review']); + }); + + it('getWorkspaceSkillsStatus refreshes the cached status on a newer live answer', async () => { + const statuses = [ + { + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [{ kind: 'skill', status: 'ok', name: 'review' }], + }, + { + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [ + { kind: 'skill', status: 'ok', name: 'review' }, + { kind: 'skill', status: 'ok', name: 'plan' }, + ], + }, + ]; + let call = 0; + const queryWorkspaceStatus = vi + .fn() + .mockImplementation(() => Promise.resolve(statuses[call++])); + const svc = createDaemonWorkspaceService( + makeDeps({ queryWorkspaceStatus, boundWorkspace: '/ws' }), + ); + + await svc.getWorkspaceSkillsStatus(makeCtx()); + const refreshed = await svc.getWorkspaceSkillsStatus(makeCtx()); + expect(refreshed.skills.map((s) => s.name)).toEqual(['review', 'plan']); + }); + + it('getWorkspaceSkillsStatus falls back to the daemon-local provider when the child never answered', async () => { + const queryWorkspaceStatus = vi + .fn() + .mockImplementation((_m: string, idle: () => unknown) => + Promise.resolve(idle()), + ); + const workspaceSkillsStatusProvider = vi.fn().mockResolvedValue({ + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [ + { + kind: 'skill', + status: 'ok', + name: 'review', + description: 'Review changed code', + level: 'bundled', + modelInvocable: true, + }, + ], + }); + const svc = createDaemonWorkspaceService( + makeDeps({ + queryWorkspaceStatus, + workspaceSkillsStatusProvider, + boundWorkspace: '/ws', + }), + ); + + const result = await svc.getWorkspaceSkillsStatus(makeCtx()); + + expect(workspaceSkillsStatusProvider).toHaveBeenCalledWith('/ws'); + expect(result.initialized).toBe(true); + expect(result.skills.map((s) => s.name)).toEqual(['review']); + }); + + it('getWorkspaceSkillsStatus prefers the cached child answer over the daemon-local provider', async () => { + const liveStatus = { + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [{ kind: 'skill', status: 'ok', name: 'review' }], + }; + let channelLive = true; + const queryWorkspaceStatus = vi + .fn() + .mockImplementation((_m: string, idle: () => unknown) => + Promise.resolve(channelLive ? liveStatus : idle()), + ); + const workspaceSkillsStatusProvider = vi.fn().mockResolvedValue({ + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [], + }); + const svc = createDaemonWorkspaceService( + makeDeps({ + queryWorkspaceStatus, + workspaceSkillsStatusProvider, + boundWorkspace: '/ws', + }), + ); + + await svc.getWorkspaceSkillsStatus(makeCtx()); // warms cache (child live) + channelLive = false; + const result = await svc.getWorkspaceSkillsStatus(makeCtx()); + + expect(result.skills.map((s) => s.name)).toEqual(['review']); + expect(workspaceSkillsStatusProvider).not.toHaveBeenCalled(); + }); + + it('getWorkspaceSkillsStatus does not use the daemon-local provider while the child answers', async () => { + const liveStatus = { + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [{ kind: 'skill', status: 'ok', name: 'review' }], + }; + const queryWorkspaceStatus = vi.fn().mockResolvedValue(liveStatus); + const workspaceSkillsStatusProvider = vi.fn().mockResolvedValue({ + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [], + }); + const svc = createDaemonWorkspaceService( + makeDeps({ queryWorkspaceStatus, workspaceSkillsStatusProvider }), + ); + + await svc.getWorkspaceSkillsStatus(makeCtx()); + + expect(workspaceSkillsStatusProvider).not.toHaveBeenCalled(); + }); + + it('getWorkspaceSkillsStatus replays the cache when the query throws mid-flight', async () => { + const liveStatus = { + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [{ kind: 'skill', status: 'ok', name: 'review' }], + }; + let shouldThrow = false; + const queryWorkspaceStatus = vi + .fn() + .mockImplementation(() => + shouldThrow + ? Promise.reject(new Error('channel closed mid-request')) + : Promise.resolve(liveStatus), + ); + const svc = createDaemonWorkspaceService( + makeDeps({ queryWorkspaceStatus, boundWorkspace: '/ws' }), + ); + + await svc.getWorkspaceSkillsStatus(makeCtx()); // warms cache (live) + shouldThrow = true; + const result = await svc.getWorkspaceSkillsStatus(makeCtx()); + + // Mid-flight failure resolves to the cached answer, not a rejection. + expect(result.skills.map((s) => s.name)).toEqual(['review']); + }); + + it('getWorkspaceSkillsStatus falls back to daemon-local when the query throws with no cache', async () => { + const queryWorkspaceStatus = vi + .fn() + .mockRejectedValue(new Error('channel closed mid-request')); + const workspaceSkillsStatusProvider = vi.fn().mockResolvedValue({ + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [{ kind: 'skill', status: 'ok', name: 'review' }], + }); + const svc = createDaemonWorkspaceService( + makeDeps({ + queryWorkspaceStatus, + workspaceSkillsStatusProvider, + boundWorkspace: '/ws', + }), + ); + + const result = await svc.getWorkspaceSkillsStatus(makeCtx()); + + expect(workspaceSkillsStatusProvider).toHaveBeenCalledWith('/ws'); + expect(result.skills.map((s) => s.name)).toEqual(['review']); + }); + + it('getWorkspaceSkillsStatus degrades to the idle placeholder when the daemon-local provider throws', async () => { + const queryWorkspaceStatus = vi + .fn() + .mockImplementation((_m: string, idle: () => unknown) => + Promise.resolve(idle()), + ); + const workspaceSkillsStatusProvider = vi + .fn() + .mockRejectedValue(new Error('local enumeration blew up')); + const svc = createDaemonWorkspaceService( + makeDeps({ + queryWorkspaceStatus, + workspaceSkillsStatusProvider, + boundWorkspace: '/ws', + }), + ); + + // A throwing injected provider must not fail the request. + const result = await svc.getWorkspaceSkillsStatus(makeCtx()); + + expect(workspaceSkillsStatusProvider).toHaveBeenCalledWith('/ws'); + expect(result.initialized).toBe(false); + expect(result.skills).toEqual([]); + expect(mockWriteStderrLine).toHaveBeenCalled(); + }); + it('getWorkspaceProvidersStatus uses daemon-local provider when present', async () => { const queryWorkspaceStatus = vi .fn() diff --git a/packages/cli/src/serve/workspace-service/index.ts b/packages/cli/src/serve/workspace-service/index.ts index 8cde332c3af..9a696bf4352 100644 --- a/packages/cli/src/serve/workspace-service/index.ts +++ b/packages/cli/src/serve/workspace-service/index.ts @@ -28,6 +28,7 @@ import { createIdleEnvStatus, createIdleAcpPreflightCells, type ServeWorkspacePreflightStatus, + type ServeWorkspaceSkillsStatus, } from '@qwen-code/acp-bridge/status'; import { @@ -161,6 +162,7 @@ export function createDaemonWorkspaceService( contextFilename, statusProvider, workspaceProvidersStatusProvider, + workspaceSkillsStatusProvider, isChannelLive, persistDisabledTools, persistSetting, @@ -171,6 +173,11 @@ export function createDaemonWorkspaceService( publishWorkspaceEvent, } = deps; + // Last skills status answered by a live ACP child, retained so + // skill-backed slash commands (e.g. `/review`) keep autocompleting after + // the child channel has been reaped. See `getWorkspaceSkillsStatus`. + let lastWorkspaceSkillsStatus: ServeWorkspaceSkillsStatus | undefined; + // -- Facade -- return { // -- Status queries (delegate to ACP child via queryWorkspaceStatus) -- @@ -182,10 +189,58 @@ export function createDaemonWorkspaceService( }, async getWorkspaceSkillsStatus(_ctx: WorkspaceRequestContext) { - return queryWorkspaceStatus( - SERVE_STATUS_EXT_METHODS.workspaceSkills, - () => createIdleWorkspaceSkillsStatus(boundWorkspace), - ); + // Skills are enumerated by the ACP child, which owns the live + // SkillManager (including extension-provided skills). `queryWorkspaceStatus` + // returns the idle placeholder (`initialized: false`, empty `skills`) + // whenever no child channel is live — before the first session, after + // the child is reaped on session close (`--channel-idle-timeout-ms` + // defaults to an immediate kill), and when a cold-start preheat times + // out before the child ever answers. In those windows the Web Shell's + // pre-first-prompt slash-command list would otherwise drop every skill, + // so `/rev` stops autocompleting `/review`. `initialized` cleanly + // separates a real child answer (always `true`) from the placeholder. + let status: ServeWorkspaceSkillsStatus; + try { + status = await queryWorkspaceStatus( + SERVE_STATUS_EXT_METHODS.workspaceSkills, + () => createIdleWorkspaceSkillsStatus(boundWorkspace), + ); + } catch (err) { + // The channel can die mid-RPC (`liveChannelInfo()` was valid at the + // check but the child exited before the call completed). Treat that + // like "no live child" and fall back to the cache / daemon-local + // enumeration below instead of failing the request — matching + // getWorkspaceEnvStatus / getWorkspacePreflightStatus. + writeStderrLine( + `qwen serve: getWorkspaceSkillsStatus query failed: ${err instanceof Error ? err.message : String(err)}`, + ); + status = createIdleWorkspaceSkillsStatus(boundWorkspace); + } + if (status.initialized) { + lastWorkspaceSkillsStatus = status; + return status; + } + // Live child unavailable. Prefer the last answer it produced (keeps the + // full, extension-aware list available across a reap)... + if (lastWorkspaceSkillsStatus) { + return lastWorkspaceSkillsStatus; + } + // ...then fall back to daemon-local enumeration, so a child that has not + // answered even once (e.g. a preheat that times out under `npm run dev`) + // still yields the on-disk skills — `/review` included. The provider + // handles its own errors, but it is injected, so guard the call too and + // degrade to the idle placeholder rather than failing the request — + // matching getWorkspaceEnvStatus / getWorkspacePreflightStatus. + if (workspaceSkillsStatusProvider) { + try { + return await workspaceSkillsStatusProvider(boundWorkspace); + } catch (err) { + writeStderrLine( + `qwen serve: getWorkspaceSkillsStatus local provider failed: ${err instanceof Error ? err.message : String(err)}`, + ); + } + } + return status; }, async getWorkspaceProvidersStatus(_ctx: WorkspaceRequestContext) { diff --git a/packages/cli/src/serve/workspace-service/types.ts b/packages/cli/src/serve/workspace-service/types.ts index f16a9ade4ae..96337078b5a 100644 --- a/packages/cli/src/serve/workspace-service/types.ts +++ b/packages/cli/src/serve/workspace-service/types.ts @@ -38,6 +38,7 @@ import type { import type { WorkspaceVoiceStatus } from '../../services/voice-service.js'; import type { VoiceMode } from '../../services/voice-settings.js'; import type { WorkspaceProvidersStatusProvider } from '../workspace-providers-status.js'; +import type { WorkspaceSkillsStatusProvider } from '../workspace-skills-status.js'; // --------------------------------------------------------------------------- // WorkspaceRequestContext @@ -324,6 +325,15 @@ export interface DaemonWorkspaceServiceDeps { */ workspaceProvidersStatusProvider?: WorkspaceProvidersStatusProvider; + /** + * Daemon-local skill enumeration. Used as a fallback for + * `/workspace/skills` when the ACP child cannot answer (e.g. before the + * first prompt on a cold daemon whose preheat has not yet — or cannot — + * bring the child up), so skill-backed slash commands autocomplete without + * waiting on the child. The live child stays authoritative when present. + */ + workspaceSkillsStatusProvider?: WorkspaceSkillsStatusProvider; + /** * Returns whether the ACP channel is currently live. Used by * `getWorkspaceEnvStatus` to populate the `acpChannelLive` field diff --git a/packages/cli/src/serve/workspace-skills-mapping.test.ts b/packages/cli/src/serve/workspace-skills-mapping.test.ts new file mode 100644 index 00000000000..33f73acb49c --- /dev/null +++ b/packages/cli/src/serve/workspace-skills-mapping.test.ts @@ -0,0 +1,59 @@ +/** + * @license + * Copyright 2025 Qwen Team + * SPDX-License-Identifier: Apache-2.0 + */ + +import { describe, it, expect } from 'vitest'; +import type { SkillConfig } from '@qwen-code/qwen-code-core'; +import { mapSkillConfigToStatus } from './workspace-skills-mapping.js'; + +function makeSkill(overrides: Partial = {}): SkillConfig { + return { + name: 'review', + description: 'Review changed code', + level: 'bundled', + ...overrides, + } as SkillConfig; +} + +describe('mapSkillConfigToStatus', () => { + it('maps an invocable skill to an ok status with its core fields', () => { + const status = mapSkillConfigToStatus( + makeSkill({ argumentHint: '[pr-number]' }), + ); + + expect(status).toEqual({ + kind: 'skill', + status: 'ok', + name: 'review', + description: 'Review changed code', + level: 'bundled', + modelInvocable: true, + argumentHint: '[pr-number]', + }); + }); + + it('marks a disable-model-invocation skill as disabled', () => { + const status = mapSkillConfigToStatus( + makeSkill({ name: 'internal', disableModelInvocation: true }), + ); + + expect(status.status).toBe('disabled'); + expect(status.modelInvocable).toBe(false); + expect(status.name).toBe('internal'); + }); + + it('surfaces optional model and extensionName only when present', () => { + expect(mapSkillConfigToStatus(makeSkill())).not.toHaveProperty('model'); + expect(mapSkillConfigToStatus(makeSkill())).not.toHaveProperty( + 'extensionName', + ); + + const status = mapSkillConfigToStatus( + makeSkill({ model: 'gpt-4o', extensionName: 'acme' }), + ); + expect(status.model).toBe('gpt-4o'); + expect(status.extensionName).toBe('acme'); + }); +}); diff --git a/packages/cli/src/serve/workspace-skills-mapping.ts b/packages/cli/src/serve/workspace-skills-mapping.ts new file mode 100644 index 00000000000..97e13080e3b --- /dev/null +++ b/packages/cli/src/serve/workspace-skills-mapping.ts @@ -0,0 +1,32 @@ +/** + * @license + * Copyright 2025 Qwen Team + * SPDX-License-Identifier: Apache-2.0 + */ + +import type { SkillConfig } from '@qwen-code/qwen-code-core'; +import type { ServeWorkspaceSkillStatus } from '@qwen-code/acp-bridge/status'; + +/** + * Maps a `SkillConfig` (as `SkillManager.listSkills()` returns) to the + * `/workspace/skills` wire status. Shared by the ACP child's + * `buildWorkspaceSkillsStatus` and the daemon-local + * `workspace-skills-status` provider so the two skill listings can never + * drift in shape. + */ +export function mapSkillConfigToStatus( + skill: SkillConfig, +): ServeWorkspaceSkillStatus { + const modelInvocable = skill.disableModelInvocation !== true; + return { + kind: 'skill', + status: modelInvocable ? 'ok' : 'disabled', + name: skill.name, + description: skill.description, + level: skill.level, + modelInvocable, + ...(skill.argumentHint ? { argumentHint: skill.argumentHint } : {}), + ...(skill.model ? { model: skill.model } : {}), + ...(skill.extensionName ? { extensionName: skill.extensionName } : {}), + }; +} diff --git a/packages/cli/src/serve/workspace-skills-status.test.ts b/packages/cli/src/serve/workspace-skills-status.test.ts new file mode 100644 index 00000000000..7ee0ecab819 --- /dev/null +++ b/packages/cli/src/serve/workspace-skills-status.test.ts @@ -0,0 +1,78 @@ +/** + * @license + * Copyright 2025 Qwen Team + * SPDX-License-Identifier: Apache-2.0 + */ + +import { describe, it, expect, vi, afterEach } from 'vitest'; + +const mockWriteStderrLine = vi.hoisted(() => vi.fn()); +vi.mock('../utils/stdioHelpers.js', () => ({ + writeStderrLine: mockWriteStderrLine, +})); + +import { SkillManager } from '@qwen-code/qwen-code-core'; +import { createWorkspaceSkillsStatusProvider } from './workspace-skills-status.js'; + +describe('createWorkspaceSkillsStatusProvider', () => { + afterEach(() => { + vi.restoreAllMocks(); + mockWriteStderrLine.mockClear(); + }); + + it('enumerates bundled skills (including /review) without an ACP child', async () => { + const provider = createWorkspaceSkillsStatusProvider(); + + const status = await provider(process.cwd()); + + expect(status.initialized).toBe(true); + const review = status.skills.find((skill) => skill.name === 'review'); + expect(review).toBeDefined(); + expect(review?.kind).toBe('skill'); + expect(review?.level).toBe('bundled'); + // Skill-tool listing exposes the model-invocable flag; bundled /review is + // invocable, and the argument hint drives the slash-command autocomplete. + expect(review?.modelInvocable).toBe(true); + expect(review?.argumentHint).toBeTruthy(); + }); + + it('reports the queried workspace path', async () => { + const provider = createWorkspaceSkillsStatusProvider(); + + const status = await provider('/some/workspace'); + + expect(status.workspaceCwd).toBe('/some/workspace'); + }); + + it('returns a non-initialized error status (and logs) when enumeration fails', async () => { + vi.spyOn(SkillManager.prototype, 'listSkills').mockRejectedValueOnce( + new Error('boom'), + ); + const provider = createWorkspaceSkillsStatusProvider(); + + const status = await provider('/ws'); + + expect(status.initialized).toBe(false); + expect(status.skills).toEqual([]); + expect(status.workspaceCwd).toBe('/ws'); + expect(status.errors).toEqual([ + { kind: 'skills', status: 'error', error: 'boom' }, + ]); + // Non-fatal failures are logged to the daemon's stderr. + expect(mockWriteStderrLine).toHaveBeenCalledTimes(1); + expect(mockWriteStderrLine.mock.calls[0][0]).toContain('boom'); + }); + + it('reuses one SkillManager per workspace across calls', async () => { + const listSpy = vi.spyOn(SkillManager.prototype, 'listSkills'); + const provider = createWorkspaceSkillsStatusProvider(); + + await provider('/ws'); + await provider('/ws'); + + // Memoized: the second query reuses the first SkillManager instance, so + // listSkills is invoked on the same object rather than a freshly-scanned one. + expect(listSpy).toHaveBeenCalledTimes(2); + expect(listSpy.mock.instances[0]).toBe(listSpy.mock.instances[1]); + }); +}); diff --git a/packages/cli/src/serve/workspace-skills-status.ts b/packages/cli/src/serve/workspace-skills-status.ts new file mode 100644 index 00000000000..8d0b333e733 --- /dev/null +++ b/packages/cli/src/serve/workspace-skills-status.ts @@ -0,0 +1,118 @@ +/** + * @license + * Copyright 2025 Qwen Team + * SPDX-License-Identifier: Apache-2.0 + */ + +/** + * Daemon-local workspace skills enumeration. + * + * `/workspace/skills` is normally answered by the ACP child (which owns the + * live `SkillManager`). But the child is not always available before the + * first prompt: session creation is deferred until then, and the startup + * preheat can time out on a slow cold start — most visibly under + * `npm run dev`, where the child is transpiled on demand and its + * `initialize` handshake routinely exceeds the 10s preheat budget, so no + * channel ever comes up. In that window the child cannot list skills, which + * drops skill-backed slash commands (e.g. `/review`) from the Web Shell's + * pre-first-prompt autocomplete even though the skills exist on disk. + * + * This provider enumerates skills directly from the filesystem via + * `SkillManager`, with no child and no MCP initialization, so the daemon can + * answer `/workspace/skills` instantly whenever the child is unavailable. + * `SkillManager.listSkills()` only reads a handful of `Config` getters + * (safe/bare mode, project root, active extensions), so a lightweight config + * shim is sufficient — no full `Config` construction (and no `initialize()` + * side effects) required. The live child, when present, stays authoritative: + * the facade only falls back here after a real child answer and the cached + * last answer are both unavailable, and this daemon-local view intentionally + * omits extension-provided skills (there is no active-extension context + * outside the child) — those still surface once a session exists. + */ + +import { SkillManager, isSafeModeEnv } from '@qwen-code/qwen-code-core'; +import type { Config } from '@qwen-code/qwen-code-core'; +import type { ServeWorkspaceSkillsStatus } from '@qwen-code/acp-bridge/status'; +import { STATUS_SCHEMA_VERSION } from '@qwen-code/acp-bridge/status'; +import { writeStderrLine } from '../utils/stdioHelpers.js'; +import { mapSkillConfigToStatus } from './workspace-skills-mapping.js'; + +export type WorkspaceSkillsStatusProvider = ( + workspaceCwd: string, +) => Promise; + +/** + * The `Config` surface `SkillManager.listSkills()` actually reads. Declaring it + * as a `Pick` (rather than casting an inline object literal) type-checks the + * shimmed getters against `Config`'s real signatures, so a signature drift is + * caught at compile time. Should `SkillManager` grow a dependency on some other + * `Config` method, that call would be `undefined` at runtime — which + * `buildWorkspaceSkillsStatus`'s try/catch turns into an empty, non-initialized + * status (the facade then leaves skills to the live child) rather than a crash. + */ +type SkillManagerConfigShim = Pick< + Config, + 'isSafeMode' | 'getBareMode' | 'getProjectRoot' | 'getActiveExtensions' +>; + +export function createWorkspaceSkillsStatusProvider(): WorkspaceSkillsStatusProvider { + // Reuse one SkillManager per workspace so repeat queries hit its in-memory + // skills cache instead of re-scanning (and re-parsing frontmatter / compiling + // globs for) every level on each call. This is a best-effort pre-child + // fallback, so the slight staleness — a skill added on disk mid-run is not + // picked up until the daemon restarts — is acceptable: the live child + // re-lists authoritatively once a session exists. + const managers = new Map(); + return (workspaceCwd) => buildWorkspaceSkillsStatus(workspaceCwd, managers); +} + +async function buildWorkspaceSkillsStatus( + workspaceCwd: string, + managers: Map, +): Promise { + try { + let skillManager = managers.get(workspaceCwd); + if (!skillManager) { + const shim: SkillManagerConfigShim = { + // Honor the safe-mode env the same way `Config` does when no explicit + // flag is passed, so an operator running in safe mode gets the same + // bundled-only listing the child would produce. + isSafeMode: () => isSafeModeEnv(), + // Bare mode is the interactive `--bare` CLI flag; the daemon never runs + // bare, so it is always off here. + getBareMode: () => false, + getProjectRoot: () => workspaceCwd, + // Extension skills need active-extension context that only the child + // has; omit them here and let the session snapshot surface them. + getActiveExtensions: () => [], + }; + skillManager = new SkillManager(shim as Config); + managers.set(workspaceCwd, skillManager); + } + const skills = await skillManager.listSkills(); + return { + v: STATUS_SCHEMA_VERSION, + workspaceCwd, + initialized: true, + skills: skills.map(mapSkillConfigToStatus), + }; + } catch (error) { + const message = error instanceof Error ? error.message : String(error); + writeStderrLine( + `qwen serve: daemon-local skills enumeration failed for ${workspaceCwd}: ${message}`, + ); + return { + v: STATUS_SCHEMA_VERSION, + workspaceCwd, + initialized: false, + skills: [], + errors: [ + { + kind: 'skills', + status: 'error', + error: message, + }, + ], + }; + } +}