Skip to content

Commit 8360985

Browse files
authored
fix(server): discover Claude commands in each workspace (pingdotgg#15462)
1 parent 32b77f4 commit 8360985

13 files changed

Lines changed: 672 additions & 62 deletions

File tree

‎apps/mobile/src/features/threads/use-composer-command-menu.test.ts‎

Lines changed: 224 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,14 @@
1-
import { describe, expect, it, vi } from "vite-plus/test";
2-
import { ProviderDriverKind } from "@t3tools/contracts";
1+
import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
2+
import {
3+
EnvironmentId,
4+
ProviderDriverKind,
5+
ProviderInstanceId,
6+
type ServerProvider,
7+
} from "@t3tools/contracts";
8+
import { act, createElement } from "react";
9+
import { createRoot, type Root } from "react-dom/client";
10+
11+
const refreshProviders = vi.hoisted(() => vi.fn());
312
vi.mock("react-native", () => ({ Alert: { alert: vi.fn() } }));
413

514
vi.mock("../../state/queries", () => ({
@@ -8,19 +17,21 @@ vi.mock("../../state/queries", () => ({
817
}));
918
vi.mock("../../state/use-composer-drafts", () => ({
1019
getComposerDraftSnapshot: vi.fn(),
20+
readComposerDraftSelection: vi.fn(),
1121
setComposerDraftContext: vi.fn(),
1222
}));
1323
vi.mock("../../lib/uuid", () => ({ uuidv4: () => "context-id" }));
1424
vi.mock("../../state/server", () => ({
1525
serverEnvironment: { refreshProviders: Symbol("refreshProviders") },
1626
}));
1727
vi.mock("../../state/use-atom-command", () => ({
18-
useAtomCommand: () => vi.fn(),
28+
useAtomCommand: () => refreshProviders,
1929
}));
2030

2131
import {
2232
buildComposerSlashCommandItems,
2333
resolveComposerCommandSelection,
34+
useComposerCommandMenu,
2435
} from "./use-composer-command-menu";
2536

2637
describe("mobile slash commands", () => {
@@ -101,3 +112,213 @@ describe("mobile slash commands", () => {
101112
).toEqual({ text: "/plan ", cursor: 6, interactionMode: null });
102113
});
103114
});
115+
116+
describe("workspace command discovery retry", () => {
117+
let root: Root;
118+
const environmentId = EnvironmentId.make("test-environment");
119+
const instanceId = ProviderInstanceId.make("claude");
120+
const provider = {
121+
instanceId,
122+
driver: ProviderDriverKind.make("claude"),
123+
enabled: true,
124+
installed: true,
125+
version: "1.0.0",
126+
status: "ready",
127+
auth: { status: "authenticated" },
128+
checkedAt: "2026-01-01T00:00:00.000Z",
129+
models: [],
130+
slashCommands: [],
131+
skills: [],
132+
workspaceSnapshots: [
133+
{
134+
cwd: "/project-a",
135+
checkedAt: "2026-01-01T00:00:00.000Z",
136+
slashCommandsPending: true,
137+
slashCommands: [{ name: "compact" }],
138+
skills: [],
139+
},
140+
],
141+
} satisfies ServerProvider;
142+
143+
function Probe({ cwd, status = provider }: { cwd: string; status?: ServerProvider }) {
144+
useComposerCommandMenu({
145+
draftMessage: "/project",
146+
ownerKey: null,
147+
environmentId,
148+
projectCwd: cwd,
149+
selectedProviderStatus: status,
150+
hasThread: false,
151+
hasCompactableConversation: false,
152+
onChangeDraftMessage: () => {},
153+
});
154+
return null;
155+
}
156+
157+
beforeEach(() => {
158+
vi.useFakeTimers();
159+
refreshProviders.mockReset();
160+
refreshProviders.mockResolvedValue({ _tag: "Success", value: { providers: [provider] } });
161+
const document = { nodeType: 9, addEventListener() {}, removeEventListener() {} };
162+
const container = {
163+
nodeType: 1,
164+
tagName: "DIV",
165+
namespaceURI: "http://www.w3.org/1999/xhtml",
166+
ownerDocument: document,
167+
addEventListener() {},
168+
removeEventListener() {},
169+
};
170+
vi.stubGlobal("document", document);
171+
vi.stubGlobal("window", { document, HTMLIFrameElement: EventTarget });
172+
vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
173+
root = createRoot(container as unknown as HTMLElement);
174+
});
175+
176+
afterEach(async () => {
177+
await act(async () => {
178+
root.unmount();
179+
});
180+
vi.useRealTimers();
181+
vi.unstubAllGlobals();
182+
});
183+
184+
it("retries partial commands after the cooldown without editing the draft", async () => {
185+
const recovered = {
186+
...provider,
187+
workspaceSnapshots: [{ ...provider.workspaceSnapshots[0], slashCommandsPending: false }],
188+
};
189+
refreshProviders.mockResolvedValueOnce({ _tag: "Success", value: { providers: [provider] } });
190+
refreshProviders.mockResolvedValue({ _tag: "Success", value: { providers: [recovered] } });
191+
await act(async () => {
192+
root.render(createElement(Probe, { cwd: "/project-a" }));
193+
});
194+
expect(refreshProviders).toHaveBeenCalledTimes(1);
195+
await act(() => vi.advanceTimersByTimeAsync(9_999));
196+
expect(refreshProviders).toHaveBeenCalledTimes(1);
197+
await act(() => vi.advanceTimersByTimeAsync(1));
198+
expect(refreshProviders).toHaveBeenCalledTimes(2);
199+
expect(refreshProviders).toHaveBeenLastCalledWith({
200+
environmentId,
201+
input: { instanceId, cwd: "/project-a" },
202+
});
203+
await act(() => vi.advanceTimersByTimeAsync(20_000));
204+
expect(refreshProviders).toHaveBeenCalledTimes(2);
205+
});
206+
207+
it.each(["pi", "acpRegistry"])(
208+
"does not poll a healthy %s workspace without discovery",
209+
async (driver) => {
210+
const unsupported = {
211+
...provider,
212+
driver: ProviderDriverKind.make(driver),
213+
workspaceSnapshots: [],
214+
};
215+
refreshProviders.mockResolvedValue({ _tag: "Success", value: { providers: [unsupported] } });
216+
await act(async () => {
217+
root.render(createElement(Probe, { cwd: "/project-a", status: unsupported }));
218+
});
219+
expect(refreshProviders).toHaveBeenCalledTimes(1);
220+
await act(() => vi.advanceTimersByTimeAsync(30_000));
221+
expect(refreshProviders).toHaveBeenCalledTimes(1);
222+
expect(vi.getTimerCount()).toBe(0);
223+
},
224+
);
225+
226+
it("arms the remaining cooldown when a concurrent scan publishes partial commands", async () => {
227+
const missing = { ...provider, workspaceSnapshots: [] };
228+
const recovered = {
229+
...provider,
230+
workspaceSnapshots: provider.workspaceSnapshots.map((snapshot) => ({
231+
...snapshot,
232+
slashCommandsPending: false,
233+
})),
234+
};
235+
refreshProviders.mockResolvedValueOnce({ _tag: "Success", value: { providers: [missing] } });
236+
refreshProviders.mockResolvedValue({ _tag: "Success", value: { providers: [recovered] } });
237+
await act(async () => {
238+
root.render(createElement(Probe, { cwd: "/project-a", status: missing }));
239+
});
240+
await act(() => vi.advanceTimersByTimeAsync(5_000));
241+
expect(refreshProviders).toHaveBeenCalledTimes(1);
242+
expect(vi.getTimerCount()).toBe(0);
243+
await act(async () => {
244+
root.render(createElement(Probe, { cwd: "/project-a", status: provider }));
245+
});
246+
await act(() => vi.advanceTimersByTimeAsync(4_999));
247+
expect(refreshProviders).toHaveBeenCalledTimes(1);
248+
await act(() => vi.advanceTimersByTimeAsync(1));
249+
expect(refreshProviders).toHaveBeenCalledTimes(2);
250+
await act(() => vi.advanceTimersByTimeAsync(20_000));
251+
expect(refreshProviders).toHaveBeenCalledTimes(2);
252+
});
253+
254+
it("does not retry when a concurrent scan publishes a complete workspace", async () => {
255+
const missing = { ...provider, workspaceSnapshots: [] };
256+
const recovered = {
257+
...provider,
258+
workspaceSnapshots: provider.workspaceSnapshots.map((snapshot) => ({
259+
...snapshot,
260+
slashCommandsPending: false,
261+
})),
262+
};
263+
refreshProviders.mockResolvedValue({ _tag: "Success", value: { providers: [missing] } });
264+
await act(async () => {
265+
root.render(createElement(Probe, { cwd: "/project-a", status: missing }));
266+
});
267+
await act(() => vi.advanceTimersByTimeAsync(5_000));
268+
await act(async () => {
269+
root.render(createElement(Probe, { cwd: "/project-a", status: recovered }));
270+
});
271+
await act(() => vi.advanceTimersByTimeAsync(30_000));
272+
expect(refreshProviders).toHaveBeenCalledTimes(1);
273+
expect(vi.getTimerCount()).toBe(0);
274+
});
275+
276+
it("retries a rejected refresh while published discovery remains pending", async () => {
277+
const recovered = {
278+
...provider,
279+
workspaceSnapshots: provider.workspaceSnapshots.map((snapshot) => ({
280+
...snapshot,
281+
slashCommandsPending: false,
282+
})),
283+
};
284+
refreshProviders.mockRejectedValueOnce(new Error("Connection lost"));
285+
refreshProviders.mockResolvedValue({ _tag: "Success", value: { providers: [recovered] } });
286+
await act(async () => {
287+
root.render(createElement(Probe, { cwd: "/project-a" }));
288+
});
289+
await act(() => vi.advanceTimersByTimeAsync(10_000));
290+
expect(refreshProviders).toHaveBeenCalledTimes(2);
291+
await act(() => vi.advanceTimersByTimeAsync(20_000));
292+
expect(refreshProviders).toHaveBeenCalledTimes(2);
293+
});
294+
295+
it("cancels the old workspace retry and does not duplicate an in-flight request", async () => {
296+
await act(async () => {
297+
root.render(createElement(Probe, { cwd: "/project-a" }));
298+
});
299+
refreshProviders.mockImplementationOnce(() => new Promise(() => {}));
300+
await act(async () => {
301+
root.render(createElement(Probe, { cwd: "/project-b" }));
302+
});
303+
expect(refreshProviders).toHaveBeenCalledTimes(2);
304+
await act(() => vi.advanceTimersByTimeAsync(20_000));
305+
expect(refreshProviders).toHaveBeenCalledTimes(2);
306+
expect(refreshProviders).toHaveBeenLastCalledWith({
307+
environmentId,
308+
input: { instanceId, cwd: "/project-b" },
309+
});
310+
expect(vi.getTimerCount()).toBe(0);
311+
});
312+
313+
it("cancels a scheduled retry when the composer unmounts", async () => {
314+
await act(async () => {
315+
root.render(createElement(Probe, { cwd: "/project-a" }));
316+
});
317+
await act(async () => {
318+
root.unmount();
319+
});
320+
await act(() => vi.advanceTimersByTimeAsync(20_000));
321+
expect(refreshProviders).toHaveBeenCalledTimes(1);
322+
expect(vi.getTimerCount()).toBe(0);
323+
});
324+
});

‎apps/mobile/src/features/threads/use-composer-command-menu.ts‎

Lines changed: 43 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,7 @@ import {
3636
getProviderSkillsForSlashMenu,
3737
getProviderSlashCommandsForSlashMenu,
3838
isProviderSkillUserInvocable,
39+
hasCompleteProviderWorkspaceSnapshot,
3940
resolveProviderSkillsForCwd,
4041
resolveProviderSlashCommandsForCwd,
4142
} from "@t3tools/client-runtime/providerSkills";
@@ -245,17 +246,43 @@ export function useComposerCommandMenu({
245246
reportFailure: false,
246247
});
247248
const selectedProviderInstanceId = selectedProviderStatus?.instanceId;
248-
const hasWorkspaceSnapshot = Boolean(
249-
projectCwd &&
250-
selectedProviderStatus?.workspaceSnapshots?.some((snapshot) => snapshot.cwd === projectCwd),
249+
const hasWorkspaceSnapshot = hasCompleteProviderWorkspaceSnapshot(
250+
selectedProviderStatus,
251+
projectCwd,
251252
);
252253
const workspaceRefreshKeyRef = useRef<string | null>(null);
253-
const workspaceRefreshRetryRef = useRef<{ key: string; notBefore: number } | null>(null);
254+
const [workspaceRefreshRetry, setWorkspaceRefreshRetry] = useState<{
255+
key: string;
256+
notBefore: number;
257+
} | null>(null);
258+
const workspaceRefreshScopeKey =
259+
environmentId && projectCwd && selectedProviderInstanceId
260+
? `${environmentId}:${selectedProviderInstanceId}:${projectCwd}`
261+
: null;
262+
const workspaceSlashCommandsPending =
263+
selectedProviderStatus?.workspaceSnapshots?.some(
264+
(snapshot) => snapshot.cwd === projectCwd && snapshot.slashCommandsPending === true,
265+
) ?? false;
266+
useEffect(() => {
267+
if (
268+
!workspaceSlashCommandsPending ||
269+
!workspaceRefreshRetry ||
270+
workspaceRefreshRetry.key !== workspaceRefreshScopeKey
271+
)
272+
return;
273+
const timeout = setTimeout(
274+
() => {
275+
setWorkspaceRefreshRetry((current) => (current === workspaceRefreshRetry ? null : current));
276+
},
277+
Math.max(0, workspaceRefreshRetry.notBefore - Date.now()),
278+
);
279+
return () => clearTimeout(timeout);
280+
}, [workspaceRefreshRetry, workspaceRefreshScopeKey, workspaceSlashCommandsPending]);
254281
const hadWorkspaceSnapshotRef = useRef(false);
255282
useEffect(() => {
256283
if (hadWorkspaceSnapshotRef.current && !hasWorkspaceSnapshot) {
257284
workspaceRefreshKeyRef.current = null;
258-
workspaceRefreshRetryRef.current = null;
285+
setWorkspaceRefreshRetry(null);
259286
}
260287
hadWorkspaceSnapshotRef.current = hasWorkspaceSnapshot;
261288
}, [hasWorkspaceSnapshot]);
@@ -265,29 +292,32 @@ export function useComposerCommandMenu({
265292
if (workspaceRefreshKeyRef.current === key) return;
266293
if (hasWorkspaceSnapshot) {
267294
workspaceRefreshKeyRef.current = key;
268-
workspaceRefreshRetryRef.current = null;
295+
setWorkspaceRefreshRetry(null);
269296
return;
270297
}
271-
const retry = workspaceRefreshRetryRef.current;
298+
const retry = workspaceRefreshRetry;
272299
if (retry?.key === key && Date.now() < retry.notBefore) return;
273300
workspaceRefreshKeyRef.current = key;
274301
const retryLater = () => {
275302
if (workspaceRefreshKeyRef.current !== key) return;
276303
workspaceRefreshKeyRef.current = null;
277-
workspaceRefreshRetryRef.current = {
304+
setWorkspaceRefreshRetry({
278305
key,
279306
notBefore: Date.now() + WORKSPACE_SNAPSHOT_RETRY_COOLDOWN_MS,
280-
};
307+
});
281308
};
282309
void refreshProviders({
283310
environmentId,
284311
input: { instanceId: selectedProviderInstanceId, cwd: projectCwd },
285312
}).then((result) => {
286313
const refreshed =
287314
result._tag === "Success" &&
288-
result.value.providers
289-
.find((provider) => provider.instanceId === selectedProviderInstanceId)
290-
?.workspaceSnapshots?.some((snapshot) => snapshot.cwd === projectCwd);
315+
hasCompleteProviderWorkspaceSnapshot(
316+
result.value.providers.find(
317+
(provider) => provider.instanceId === selectedProviderInstanceId,
318+
),
319+
projectCwd,
320+
);
291321
if (!refreshed && workspaceRefreshKeyRef.current === key) {
292322
retryLater();
293323
}
@@ -299,6 +329,7 @@ export function useComposerCommandMenu({
299329
projectCwd,
300330
refreshProviders,
301331
selectedProviderInstanceId,
332+
workspaceRefreshRetry,
302333
]);
303334

304335
const trigger = useMemo(() => {

‎apps/server/src/provider/Drivers/ClaudeDriver.ts‎

Lines changed: 8 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -41,6 +41,7 @@ import {
4141
checkClaudeProviderStatus,
4242
makePendingClaudeProvider,
4343
probeClaudeCapabilities,
44+
probeClaudeWorkspaceSnapshot,
4445
} from "../Layers/ClaudeProvider.ts";
4546
import { makeManagedServerProvider } from "../makeManagedServerProvider.ts";
4647
import * as ModelManifest from "../ModelManifest.ts";
@@ -69,7 +70,6 @@ import {
6970
makeClaudeContinuationGroupKey,
7071
resolveClaudeHomePath,
7172
} from "./ClaudeHome.ts";
72-
import { discoverClaudeSkills } from "./ClaudeSkills.ts";
7373
const decodeClaudeSettings = Schema.decodeSync(ClaudeSettings);
7474

7575
const DRIVER_KIND = ProviderDriverKind.make("claudeAgent");
@@ -348,16 +348,13 @@ export const ClaudeDriver: ProviderDriver<ClaudeSettings, ClaudeDriverEnv> = {
348348
snapshot,
349349
invalidateCaches: Cache.invalidateAll(capabilitiesProbeCache),
350350
snapshotForCwd: (cwd: string) =>
351-
!effectiveConfig.enabled
352-
? snapshot.getSnapshot
353-
: Effect.all([
354-
snapshot.getSnapshot,
355-
discoverClaudeSkills(effectiveConfig, cwd, processEnv),
356-
]).pipe(
357-
Effect.map(([machineSnapshot, skills]) => ({ ...machineSnapshot, skills })),
358-
Effect.provideService(FileSystem.FileSystem, fileSystem),
359-
Effect.provideService(Path.Path, path),
360-
),
351+
snapshot.getSnapshot.pipe(
352+
Effect.flatMap((machineSnapshot) =>
353+
probeClaudeWorkspaceSnapshot(effectiveConfig, machineSnapshot, cwd, processEnv),
354+
),
355+
Effect.provideService(FileSystem.FileSystem, fileSystem),
356+
Effect.provideService(Path.Path, path),
357+
),
361358
orchestrationAdapter,
362359
textGeneration,
363360
consumeResetCredit,

0 commit comments

Comments
 (0)