Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

Scope Open Knowledge thread root locators (#6721)

Nick Gomeza9f20516864e
diff --git a/packages/app/src/lib/acp/dev-thread-harness.dom.test.tsx b/packages/app/src/lib/acp/dev-thread-harness.dom.test.tsx
index b189e2031..2aa8a63f8 100644
--- a/packages/app/src/lib/acp/dev-thread-harness.dom.test.tsx
+++ b/packages/app/src/lib/acp/dev-thread-harness.dom.test.tsx
@@ -44,6 +44,23 @@ function messageTexts(client: AgentThreadClient, threadId: string): string[] {
return (client.getThreadModel(threadId)?.items ?? []).filter(isMessage).map((item) => item.text);
}
+class InertSocket {
+ static OPEN = 1;
+ readyState = 0;
+ send(): void {}
+ close(): void {}
+}
+
+function withInertSockets(client: AgentThreadClient, body: () => void): void {
+ vi.stubGlobal('WebSocket', InertSocket);
+ try {
+ body();
+ } finally {
+ client.setUrl(null);
+ vi.unstubAllGlobals();
+ }
+}
+
function takeHarness(): AcpThreadHarness {
const installed = window.__acpThreadHarness;
if (installed === undefined) throw new Error('harness did not install');
@@ -150,6 +167,65 @@ describe('injected frames reach the store through the socket path', () => {
expect(client.getThread('from-server')?.info.title).toBe('Real thread');
});
+ test('a server roster does not evict an injected thread', () => {
+ const injected = harness.openThread({ agent: CODEX });
+
+ harness.frame({ op: 'threads', threads: [] });
+
+ expect(client.getThread(injected)?.info.agent).toEqual(CODEX);
+ });
+
+ test('a server roster preserves an injected transcript', () => {
+ const injected = harness.openThread({ agent: CODEX });
+
+ harness.pushUpdates(injected, [chunk('kept')]);
+ harness.frame({ op: 'threads', threads: [] });
+
+ expect(messageTexts(client, injected)).toEqual(['kept']);
+ });
+
+ test('closing an injected thread removes its roster protection', () => {
+ const injected = harness.openThread({ agent: CODEX });
+
+ client.closeThread(injected);
+ harness.frame({ op: 'threads', threads: [] });
+
+ expect(client.getThread(injected)).toBeNull();
+ });
+
+ test('deleting an injected thread removes its roster protection', () => {
+ const injected = harness.openThread({ agent: CODEX });
+
+ client.deleteThread(injected);
+ harness.frame({ op: 'threads', threads: [] });
+
+ expect(client.getThread(injected)).toBeNull();
+ });
+
+ test('changing projects removes prior injected thread ownership', () => {
+ withInertSockets(client, () => {
+ client.setUrl('ws://project-a');
+ const injected = harness.openThread({ agent: CODEX });
+
+ client.setUrl('ws://project-b');
+ harness.frame({ op: 'threads', threads: [] });
+
+ expect(client.getThread(injected)).toBeNull();
+ });
+ });
+
+ test('a thread injected before the first project URL survives that project roster', () => {
+ withInertSockets(client, () => {
+ const injected = harness.openThread({ agent: CODEX });
+ harness.pushUpdates(injected, [chunk('early')]);
+
+ client.setUrl('ws://project-a');
+ harness.frame({ op: 'threads', threads: [] });
+
+ expect(messageTexts(client, injected)).toEqual(['early']);
+ });
+ });
+
test('uninstalling withdraws the harness from the window', () => {
uninstall();
diff --git a/packages/app/src/lib/acp/dev-thread-harness.ts b/packages/app/src/lib/acp/dev-thread-harness.ts
index cd9978e95..709d85048 100644
--- a/packages/app/src/lib/acp/dev-thread-harness.ts
+++ b/packages/app/src/lib/acp/dev-thread-harness.ts
@@ -6,7 +6,7 @@ import type {
ThreadServerFrame,
ThreadStatus,
} from '@inkeep/open-knowledge-core/acp/thread-protocol';
-import type { AgentThreadClient } from './thread-client';
+import type { AgentThreadClient, ThreadState } from './thread-client';
interface DevThreadOptions {
readonly agent: ThreadAgentInfo;
@@ -48,22 +48,69 @@ function toEvent(update: SessionUpdate): ThreadEvent {
export function installAcpThreadHarness(client: AgentThreadClient): () => void {
if (!import.meta.env.DEV) return () => {};
- const owned = new Set<string>();
+ const owned = new Map<string, ThreadState>();
+ const previousReceiveServerFrame = client.receiveServerFrame;
+ const previousSetUrl = client.setUrl;
+ const previousCloseThread = client.closeThread;
+ const previousDeleteThread = client.deleteThread;
const deliver = (frame: ThreadServerFrame): void => {
client.receiveServerFrame(JSON.stringify(frame));
};
+ const deliverUnwrapped = (frame: ThreadServerFrame): void => {
+ previousReceiveServerFrame.call(client, JSON.stringify(frame));
+ };
+
+ const captureOwned = (): void => {
+ for (const threadId of owned.keys()) {
+ const state = client.getThread(threadId);
+ if (state !== null) owned.set(threadId, state);
+ }
+ };
+
+ const restoreOwned = (): void => {
+ for (const [threadId, state] of owned) {
+ if (client.getThread(threadId) !== null) continue;
+ deliverUnwrapped({ op: 'subscribed', threadId, fromSeq: 0, info: state.info });
+ if (state.events.length > 0) {
+ deliverUnwrapped({ op: 'events', threadId, fromSeq: 0, events: [...state.events] });
+ }
+ }
+ };
+
+ client.receiveServerFrame = (data: string): void => {
+ captureOwned();
+ previousReceiveServerFrame.call(client, data);
+ restoreOwned();
+ };
+ client.setUrl = (url: string | null): void => {
+ const previousUrl = client.getThreadScope();
+ captureOwned();
+ previousSetUrl.call(client, url);
+ if (previousUrl !== null && url !== previousUrl) owned.clear();
+ };
+ client.closeThread = (threadId: string): void => {
+ owned.delete(threadId);
+ previousCloseThread.call(client, threadId);
+ };
+ client.deleteThread = (threadId: string): void => {
+ owned.delete(threadId);
+ previousDeleteThread.call(client, threadId);
+ };
+
const subscribe = (options: DevThreadOptions, lastSeq: number): string => {
syntheticCounter += 1;
const threadId = options.threadId ?? `injected-${syntheticCounter}`;
- owned.add(threadId);
+ const info = makeThreadInfo(options, threadId, lastSeq);
deliver({
op: 'subscribed',
threadId,
fromSeq: 0,
- info: makeThreadInfo(options, threadId, lastSeq),
+ info,
});
+ const state = client.getThread(threadId);
+ if (state !== null) owned.set(threadId, state);
return threadId;
};
@@ -102,6 +149,10 @@ export function installAcpThreadHarness(client: AgentThreadClient): () => void {
window.__acpThreadHarness = harness;
return () => {
+ client.receiveServerFrame = previousReceiveServerFrame;
+ client.setUrl = previousSetUrl;
+ client.closeThread = previousCloseThread;
+ client.deleteThread = previousDeleteThread;
if (window.__acpThreadHarness === harness) {
delete window.__acpThreadHarness;
}
diff --git a/packages/app/tests/stress/editor-pane-button.e2e.ts b/packages/app/tests/stress/editor-pane-button.e2e.ts
index 0a5c1cb90..34cfecc13 100644
--- a/packages/app/tests/stress/editor-pane-button.e2e.ts
+++ b/packages/app/tests/stress/editor-pane-button.e2e.ts
@@ -40,6 +40,10 @@ async function boxOf(page: Page, selector: string): Promise<Box> {
return box;
}
+function threadRootSelector(threadId: string): string {
+ return `[data-session-id="${threadId}"] [data-agent-thread-root]`;
+}
+
async function widthOf(page: Page, selector: string): Promise<number> {
return await page.evaluate((s) => {
const element = document.querySelector(s);
@@ -348,7 +352,7 @@ async function openThread(page: Page, title: string): Promise<string> {
title: threadTitle,
});
}, title);
- await expect(page.locator('[data-agent-thread-root]')).toBeVisible({
+ await expect(page.locator(threadRootSelector(threadId))).toBeVisible({
timeout: THREAD_FIRST_RENDER_TIMEOUT_MS,
});
return threadId;
@@ -371,10 +375,10 @@ type ThreadColumnPart = 'header' | 'transcript' | 'composer';
async function threadColumn(
page: Page,
+ threadId: string,
part: ThreadColumnPart = 'header',
): Promise<{ width: number; centerOffset: number }> {
- return await page.evaluate((which) => {
- const root = document.querySelector('[data-agent-thread-root]');
+ return await page.locator(threadRootSelector(threadId)).evaluate((root, which) => {
if (!(root instanceof HTMLElement)) throw new Error('no thread root');
const rootBox = root.getBoundingClientRect();
const contentBox = (element: Element | null | undefined) => {
@@ -402,22 +406,30 @@ async function threadColumn(
}
test.describe('chat on its own', () => {
+ test('opens the requested thread when another thread stays mounted', async ({ page, api }) => {
+ await openWeb(page, api, 'thread-root-scope');
+ await setHeaderPane(page, 'agents', true);
+ const backgroundThreadId = await openThread(page, 'Background');
+ await openThread(page, 'Requested');
+ await expect(page.locator(threadRootSelector(backgroundThreadId))).toHaveCount(1);
+ });
+
test('keeps its conversation at a reading width, centered, and goes back to full width beside another pane', async ({
page,
api,
}) => {
await openWeb(page, api, 'reading-width');
- await openThread(page, 'Reading width');
+ const threadId = await openThread(page, 'Reading width');
await expect(headerPaneButton(page, 'agents')).toHaveAttribute('aria-pressed', 'true');
- const besideEditor = await threadColumn(page);
+ const besideEditor = await threadColumn(page, threadId);
await setHeaderPane(page, 'editor', false);
await expectFillsRow(page, [CHAT_PANE_CARD]);
for (const part of ['header', 'transcript', 'composer'] as const) {
await expect
- .poll(async () => (await threadColumn(page, part)).width)
+ .poll(async () => (await threadColumn(page, threadId, part)).width)
.toBeLessThanOrEqual(768);
- expect((await threadColumn(page, part)).centerOffset).toBeLessThanOrEqual(1);
+ expect((await threadColumn(page, threadId, part)).centerOffset).toBeLessThanOrEqual(1);
}
expect(await widthOf(page, CHAT_PANE_CARD)).toBeGreaterThan(1200);
@@ -426,10 +438,11 @@ test.describe('chat on its own', () => {
transfer.items.add(new File(['hello'], 'hello.txt', { type: 'text/plain' }));
return transfer;
});
- await page.locator('[data-agent-thread-root]').dispatchEvent('dragenter', { dataTransfer });
+ const rootSelector = threadRootSelector(threadId);
+ await page.locator(rootSelector).dispatchEvent('dragenter', { dataTransfer });
const overlay = page.getByTestId('agent-thread-drop-overlay');
await expect(overlay).toBeVisible();
- const rootBox = await boxOf(page, '[data-agent-thread-root]');
+ const rootBox = await boxOf(page, rootSelector);
const overlayBox = await boxOf(page, '[data-testid="agent-thread-drop-overlay"]');
expect(Math.abs(overlayBox.x - rootBox.x)).toBeLessThanOrEqual(1);
expect(Math.abs(overlayBox.width - rootBox.width)).toBeLessThanOrEqual(1);
@@ -437,7 +450,7 @@ test.describe('chat on its own', () => {
await setHeaderPane(page, 'editor', true);
await expect
- .poll(async () => (await threadColumn(page)).width)
+ .poll(async () => (await threadColumn(page, threadId)).width)
.toBeCloseTo(besideEditor.width, 0);
});
});