mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-16 11:59:26 +01:00
## Thinking Path
> - Paperclip is the open source app people use to manage AI agents for
work
> - The board UI sidebar has a Recents list of the tasks a person opened
last
> - The Recents list renders from a local snapshot, but its links had no
warm-up. A click waited for the task-detail code and about nine
first-frame reads
> - Task lists (Inbox, Tasks) already warm a task on hover, press and
click, and #20355 added a batched `chat-bootstrap` read that had no UI
consumer
> - The hosted database is CPU-bound, so a fix must add at most one read
per page load and must not compete with the page's own reads
> - This pull request gives Recents the same open-intent prefetch as
task lists, warms the task-detail code, and preloads the top ten recent
tasks with one `chat-bootstrap` request after the page is idle
> - The benefit is that a click on a recent task shows its chat from
cache, without a wait for the API
## Linked Issues or Issue Description
Refs #20355 (server read this PR consumes). Builds on #20389, #20398 and
#20419.
**Is your feature request related to a problem?**
Opening a task from the sidebar's Recents was slower than opening it
from a task list. The Recents links had no prefetch. The task page
waited for its first-frame reads after the click.
**Describe the solution you'd like**
Recents links use the task lists' open-intent prefetch. When the page is
idle, one batched request loads the first frame of the most recent tasks
into the task page's caches.
**Describe alternatives you've considered**
Per-task prefetch of every recent task. That makes up to ten times nine
requests per page load, which the hosted database cannot afford.
**Additional context**
I searched open PRs and remote branches for "chat-bootstrap" and
"instant task opens". The only related work is the server-side branches
that merged as #20355. There is no other in-flight UI consumer of
`chat-bootstrap`.
## What Changed
- `ui/src/hooks/useIssueNavigationPrefetch.ts`: the open-intent handlers
from `IssueLinkQuicklook` move into one hook (light warm on pass-over;
`history: true` on a resting hover or focus, a mouse or pen press, and a
click). `IssueLinkQuicklook` now uses the hook. Its behavior does not
change.
- `ui/src/components/RecentTaskNavItem.tsx`: one Recents link wrapper
that applies the hook. The classic list (`SidebarRecentTasks`), the
Coordinator task rows and `DesignSidebar` use it. `SidebarNavItem`
accepts the handlers through a new optional `linkHandlers` prop.
- Classic Recents links now open `/issues/<identifier>` (Coordinator
already did). The old UUID link remounted the task page after a redirect
to the identifier route.
- `ui/src/hooks/useRecentTaskOpenWarmup.ts`: when Recents shows a task,
it fires the task-detail code warm-up (`useWarmTaskDetailCode`). After
two frames, a visible tab, no fetching queries and an idle callback, it
sends one `issues/chat-bootstrap?ids=` request for the ten most recent
tasks. It skips tasks whose first frame is cached and fresh. It sends no
request for an empty list or a hidden tab. It sends at most one request
per account per page load. Unmount or an account change aborts the
request.
- `ui/src/lib/issueChatBootstrapCache.ts`: `seedIssueChatBootstrap`
writes each field under the keys the task page reads, for the requested
ref, the id and the identifier: core issue, recent comments, comment
input facts (one batch, through the new `seedIssueIdBatch`), recent
activity, the recent run window (through the new shared
`buildRecentIssueRunWindow`), interactions, attachments, live runs and
active run. An explicit `null` active run is stored. A missing field is
not stored. It does not replace data that is as new or newer, data with
a read in flight, or data with a pending invalidation. Keys whose page
merges observed history (comments, activity, runs, input facts) are
filled only when empty. Items for another company are ignored.
- The seed fills the `?view=core` key, not the full detail key.
`seedIssueDetailCache` is not used: the core payload cannot stand in for
the detail read's related data, and seeding it there would suppress that
read.
- `issuesApi.chatBootstrap` client method.
- `tests/perf/collections/recent-task-open.spec.ts` and its README
section.
## Verification
Local disposable instance (`local_trusted`, production UI build,
embedded PostgreSQL, collection fixture plus 12 comments on each of 8
recent tasks, streamlined UI with the Coordinator sidebar). Journey:
open Projects with 8 Recents, wait for network idle plus 3 s, click a
recent task, measure until its latest comment is on screen. Each run
uses a fresh browser context (empty HTTP cache and storage apart from
Recents). Median of 5 runs, same server and fixture for both arms:
| Arm | Click to first chat frame | Idle page API requests |
| --- | --- | --- |
| `master` (b6f4008f9b), loopback | 227 ms (first run: 249 ms) | 24
(range 21–25) |
| This PR, loopback | 134 ms | 22 (range 21–27) |
| `master`, +150 ms on each API response | 455 ms | 19 |
| This PR, +150 ms on each API response | 135 ms | 20 (+1
`chat-bootstrap`) |
With added latency, the first frame no longer depends on API latency.
- `PAPERCLIP_COLLECTION_PERF_BASE_URL=http://127.0.0.1:<port> pnpm exec
playwright test --config tests/perf/collections/playwright.config.ts
recent-task-open.spec.ts recent-task-summaries.spec.ts`: 5 passed. On
`master` the two assertion cases fail (0 `chat-bootstrap` requests; 10
first-frame reads after the click).
- Reads that still follow a click on a preloaded task: full detail (`GET
/issues/:id`), `work-products`, `documents`, `feedback-votes`,
`tree-control/state`, `tree-holds`, `runner-goal`, `browsers`, and the
`read` mark. The `chat-bootstrap` payload does not cover them. None
gates the chat's first frame (the frame shows at 135 ms while every API
response waits 150 ms).
- Unit tests: `RecentTaskNavItem.test.tsx` (intent levels, href),
`useRecentTaskOpenWarmup.test.tsx` (one request for the top ten, code
warm-up, wait for page reads, hidden tab, fresh entries skipped, once
per account, user isolation, abort on unmount),
`issueChatBootstrapCache.test.ts` (each key in the endpoint shape,
`null` versus missing fields, company isolation, no downgrade of newer,
in-flight or invalidated data, merge keys filled only when empty).
- `ui` Vitest: `src/components src/hooks src/lib src/api` 694 files
passed; `src/pages src/App src/context` 188 files passed. `pnpm
check:token-gates`: clean. `pnpm verify` exits 2 because a `tests/` file
is a global CI input; required CI supplies the broad coverage.
## Risks
- Low to medium. One extra read per page load when Recents has tasks
without a fresh cached first frame. The read starts only after the
page's own queries settle, and the server reads at most two tasks at a
time.
- A live event that arrives while the preload is in flight, for a task
with no cached keys, can leave seeded data up to 30 s old until the next
live event or the next open after the stale time. Inbox hover prefetch
has the same window.
- Classic Recents links now use the identifier route instead of the UUID
route. The task page already redirected UUID links to this route.
- `tests/perf/collections` is a manual suite. CI does not run it.
## Model Used
- Claude Opus 5.5 (`claude-opus-5-5`), Anthropic, in Claude Code with
tool use (shell, file edits, browser automation through Playwright).
Standard context window.
## Checklist
- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have searched GitHub for duplicate or related PRs and linked
them above
- [x] I have either (a) linked existing issues with `Fixes: #` / `Closes
#` / `Refs #` OR (b) described the issue in-PR following the relevant
issue template
- [x] I have not referenced internal/instance-local Paperclip issues or
links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip`
URLs)
- [x] My branch name describes the change (e.g. `docs/...`, `fix/...`)
and contains no internal Paperclip ticket id or instance-derived details
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [ ] All Paperclip CI gates are green
- [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups
- [ ] I will address all Greptile and reviewer comments before
requesting merge
🤖 Generated with [Claude Code](https://claude.com/claude-code)
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
574 lines
20 KiB
TypeScript
574 lines
20 KiB
TypeScript
// @vitest-environment jsdom
|
|
|
|
import { act, type ReactNode } from "react";
|
|
import { createRoot, type Root } from "react-dom/client";
|
|
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
|
import { TooltipProvider } from "@/components/ui/tooltip";
|
|
import { SidebarRecentTasks } from "./SidebarRecentTasks";
|
|
import {
|
|
getRecentTasksStorageKey,
|
|
readRecentTasks,
|
|
recordRecentTask,
|
|
pruneRecentTasks,
|
|
} from "@/lib/recent-tasks";
|
|
import { queryKeys } from "@/lib/queryKeys";
|
|
|
|
const mockAuthApi = vi.hoisted(() => ({ getSession: vi.fn() }));
|
|
const mockAgentsApi = vi.hoisted(() => ({ wakeup: vi.fn() }));
|
|
const mockIssuesApi = vi.hoisted(() => ({
|
|
get: vi.fn(),
|
|
summaries: vi.fn(),
|
|
update: vi.fn(),
|
|
archiveFromInbox: vi.fn(),
|
|
getTreeControlState: vi.fn(),
|
|
createTreeHold: vi.fn(),
|
|
releaseTreeHold: vi.fn(),
|
|
chatBootstrap: vi.fn(async () => ({ items: [] })),
|
|
}));
|
|
|
|
vi.mock("@/api/agents", () => ({ agentsApi: mockAgentsApi }));
|
|
vi.mock("@/api/auth", () => ({ authApi: mockAuthApi }));
|
|
vi.mock("@/api/issues", () => ({ issuesApi: mockIssuesApi }));
|
|
vi.mock("@/lib/router", () => ({
|
|
NavLink: ({ children, to, className, ...props }: {
|
|
children: ReactNode;
|
|
to: string;
|
|
className?: string | ((state: { isActive: boolean }) => string);
|
|
}) => (
|
|
<a
|
|
href={to}
|
|
className={typeof className === "function" ? className({ isActive: false }) : className}
|
|
{...props}
|
|
>
|
|
{children}
|
|
</a>
|
|
),
|
|
}));
|
|
vi.mock("@/context/SidebarContext", () => ({
|
|
useSidebar: () => ({
|
|
collapsed: false,
|
|
peeking: false,
|
|
isMobile: false,
|
|
setSidebarOpen: vi.fn(),
|
|
}),
|
|
}));
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
(globalThis as any).IS_REACT_ACT_ENVIRONMENT = true;
|
|
|
|
describe("SidebarRecentTasks", () => {
|
|
let container: HTMLDivElement;
|
|
let root: Root;
|
|
|
|
beforeEach(() => {
|
|
window.localStorage.clear();
|
|
Object.values(mockAgentsApi).forEach((mock) => mock.mockReset());
|
|
Object.values(mockIssuesApi).forEach((mock) => mock.mockReset());
|
|
mockIssuesApi.summaries.mockImplementation(async (_company: string, ids: string[]) => {
|
|
const rows = await Promise.all(ids.map(id => mockIssuesApi.get.getMockImplementation()?.(id)));
|
|
return rows.filter(row => row && !row.hiddenAt);
|
|
});
|
|
container = document.createElement("div");
|
|
document.body.appendChild(container);
|
|
root = createRoot(container);
|
|
mockAuthApi.getSession.mockResolvedValue({
|
|
session: { id: "session-1", userId: "user-1" },
|
|
user: { id: "user-1", name: "Board", email: "board@example.test", image: null },
|
|
});
|
|
});
|
|
|
|
afterEach(() => {
|
|
act(() => root.unmount());
|
|
container.remove();
|
|
vi.clearAllMocks();
|
|
vi.useRealTimers();
|
|
});
|
|
|
|
async function render() {
|
|
const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
|
|
await act(async () => {
|
|
root.render(
|
|
<QueryClientProvider client={queryClient}>
|
|
<TooltipProvider>
|
|
<SidebarRecentTasks companyId="company-1" liveIssueIds={new Set(["issue-1"])} />
|
|
</TooltipProvider>
|
|
</QueryClientProvider>,
|
|
);
|
|
});
|
|
await act(async () => {
|
|
for (let index = 0; index < 5; index += 1) {
|
|
await Promise.resolve();
|
|
await new Promise((resolve) => window.setTimeout(resolve, 0));
|
|
}
|
|
});
|
|
return queryClient;
|
|
}
|
|
|
|
async function openActions(taskTitle: string) {
|
|
const actions = container.querySelector<HTMLButtonElement>(
|
|
`button[aria-label="More actions for ${taskTitle}"]`,
|
|
);
|
|
await act(async () => {
|
|
actions?.dispatchEvent(new PointerEvent("pointerdown", { bubbles: true }));
|
|
await Promise.resolve();
|
|
});
|
|
}
|
|
|
|
function menuItem(label: string) {
|
|
return Array.from(document.body.querySelectorAll<HTMLElement>('[role="menuitem"]'))
|
|
.find((item) => item.textContent?.trim() === label);
|
|
}
|
|
|
|
function setInputValue(input: HTMLInputElement, value: string) {
|
|
const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value")?.set;
|
|
setter?.call(input, value);
|
|
input.dispatchEvent(new Event("input", { bubbles: true }));
|
|
}
|
|
|
|
it("hides the section when there are no recent tasks", async () => {
|
|
await render();
|
|
expect(container.textContent).not.toContain("Recent Tasks");
|
|
expect(container.textContent).not.toContain("Open or create a task");
|
|
});
|
|
|
|
it("renders refreshed task text and live state without shifting for a status icon", async () => {
|
|
recordRecentTask({
|
|
id: "issue-1",
|
|
companyId: "company-1",
|
|
title: "Initial title",
|
|
identifier: "PAP-1",
|
|
status: "todo",
|
|
updatedAt: new Date(1),
|
|
}, "user-1");
|
|
mockIssuesApi.get.mockResolvedValue({
|
|
id: "issue-1",
|
|
companyId: "company-1",
|
|
title: "Refreshed title",
|
|
identifier: "PAP-1",
|
|
status: "in_progress",
|
|
hiddenAt: null,
|
|
updatedAt: new Date(2),
|
|
});
|
|
|
|
const queryClient = await render();
|
|
await act(async () => {
|
|
for (let index = 0; index < 5; index += 1) {
|
|
await Promise.resolve();
|
|
await new Promise((resolve) => window.setTimeout(resolve, 0));
|
|
}
|
|
});
|
|
|
|
const link = container.querySelector('a[href="/issues/PAP-1"]');
|
|
expect(mockIssuesApi.get).not.toHaveBeenCalled();
|
|
expect(mockIssuesApi.summaries).toHaveBeenCalledTimes(1);
|
|
expect(queryClient.getQueryData(["issues", "detail", "issue-1"])).toBeUndefined();
|
|
expect(link?.textContent).toContain("Refreshed title");
|
|
expect(link?.textContent).toContain("1 live");
|
|
expect(link?.querySelector('[aria-label="In Progress"]')).toBeNull();
|
|
expect(link?.querySelector('[data-slot="recent-task-icon-spacer"]')).toBeNull();
|
|
expect(link?.querySelector('[data-slot="sidebar-nav-icon"]')).toBeNull();
|
|
expect(link?.firstElementChild?.textContent).toBe("Refreshed title");
|
|
const actions = container.querySelector<HTMLButtonElement>(
|
|
'button[aria-label="More actions for Refreshed title"]',
|
|
);
|
|
expect(actions).not.toBeNull();
|
|
expect(actions?.className).toContain("opacity-0");
|
|
});
|
|
|
|
it("keeps rows stable during alternating activity and applies the final order after quiet", async () => {
|
|
const tasks = [1, 2, 3].map((id) => ({
|
|
id: `issue-${id}`,
|
|
companyId: "company-1",
|
|
title: `Task ${id}`,
|
|
identifier: `PAP-${id}`,
|
|
status: "done" as const,
|
|
hiddenAt: null,
|
|
projectId: null,
|
|
updatedAt: new Date(id),
|
|
}));
|
|
tasks.forEach((task) => recordRecentTask(task, "user-1"));
|
|
mockIssuesApi.get.mockImplementation(async (id: string) => tasks.find((task) => task.id === id));
|
|
const queryClient = await render();
|
|
const order = () => Array.from(container.querySelectorAll("a")).map((link) => link.getAttribute("href"));
|
|
// Links open the identifier route the task page settles on.
|
|
const originalOrder = ["/issues/PAP-3", "/issues/PAP-2", "/issues/PAP-1"];
|
|
expect(order()).toEqual(originalOrder);
|
|
vi.useFakeTimers();
|
|
|
|
for (let index = 0; index < 6; index += 1) {
|
|
const task = tasks[index % 2]!;
|
|
await act(async () => {
|
|
queryClient.setQueryData(queryKeys.issues.detail(task.id), {
|
|
...task, title: `Updated ${task.id}`, updatedAt: new Date(100 + index),
|
|
});
|
|
await vi.advanceTimersByTimeAsync(0);
|
|
});
|
|
await act(async () => { await vi.advanceTimersByTimeAsync(500); });
|
|
expect(order()).toEqual(originalOrder);
|
|
expect(container.textContent).toContain(`Updated ${task.id}`);
|
|
}
|
|
|
|
await act(async () => { await vi.advanceTimersByTimeAsync(499); });
|
|
expect(order()).toEqual(originalOrder);
|
|
await act(async () => { await vi.advanceTimersByTimeAsync(1); });
|
|
expect(order()).toEqual(["/issues/PAP-2", "/issues/PAP-1", "/issues/PAP-3"]);
|
|
expect(mockIssuesApi.get).not.toHaveBeenCalled();
|
|
expect(mockIssuesApi.summaries).toHaveBeenCalledTimes(1);
|
|
queryClient.clear();
|
|
});
|
|
|
|
it("adds and removes tasks immediately while an activity reorder is pending", async () => {
|
|
const task = (id: string, recordedAt: number) => ({
|
|
id, companyId: "company-1", title: id, identifier: id,
|
|
status: "todo" as const, updatedAt: new Date(recordedAt),
|
|
});
|
|
recordRecentTask(task("first", 1), "user-1");
|
|
recordRecentTask(task("second", 2), "user-1");
|
|
mockIssuesApi.get.mockImplementation(async (id: string) => task(id, 0));
|
|
const queryClient = await render();
|
|
vi.useFakeTimers();
|
|
act(() => recordRecentTask(task("first", 3), "user-1"));
|
|
expect(container.querySelector("a")?.getAttribute("href")).toBe("/issues/second");
|
|
await act(async () => {
|
|
recordRecentTask(task("new", 4), "user-1");
|
|
await vi.advanceTimersByTimeAsync(0);
|
|
});
|
|
expect(container.querySelector("a")?.getAttribute("href")).toBe("/issues/new");
|
|
act(() => pruneRecentTasks(getRecentTasksStorageKey("company-1", "user-1"), "company-1", new Set(["second"])));
|
|
expect(container.querySelector('a[href="/issues/second"]')).toBeNull();
|
|
await act(async () => { await vi.advanceTimersByTimeAsync(2_000); });
|
|
expect(container.querySelector('a[href="/issues/second"]')).toBeNull();
|
|
queryClient.clear();
|
|
});
|
|
|
|
it("opens the compact task actions menu from the ellipsis button", async () => {
|
|
recordRecentTask({
|
|
id: "issue-1",
|
|
companyId: "company-1",
|
|
title: "Menu task",
|
|
identifier: "PAP-1",
|
|
status: "todo",
|
|
updatedAt: new Date(1),
|
|
}, "user-1");
|
|
mockIssuesApi.get.mockResolvedValue({
|
|
id: "issue-1",
|
|
companyId: "company-1",
|
|
title: "Menu task",
|
|
identifier: "PAP-1",
|
|
status: "todo",
|
|
hiddenAt: null,
|
|
updatedAt: new Date(1),
|
|
});
|
|
|
|
await render();
|
|
await openActions("Menu task");
|
|
|
|
const menu = document.body.querySelector('[data-slot="dropdown-menu-content"]');
|
|
expect(menu?.textContent).toContain("Rename");
|
|
expect(menu?.textContent).toContain("Archive");
|
|
expect(menu?.textContent).toContain("Pause/Restart");
|
|
});
|
|
|
|
it("keeps an idle Slack conversation in recent history and labels it Idle", async () => {
|
|
const issue = {
|
|
id: "issue-1", companyId: "company-1", title: "Slack conversation", identifier: "PAP-1",
|
|
status: "in_review" as const, externalConversationState: "waiting" as const,
|
|
updatedAt: new Date(1), hiddenAt: null,
|
|
};
|
|
recordRecentTask(issue, "user-1");
|
|
mockIssuesApi.get.mockResolvedValue(issue);
|
|
await render();
|
|
expect(container.textContent).toContain("Slack conversation");
|
|
expect(container.textContent).toContain("Idle");
|
|
});
|
|
|
|
it("archives a task from the inbox without hiding or removing the recent task", async () => {
|
|
const issue = {
|
|
id: "issue-1",
|
|
companyId: "company-1",
|
|
title: "Archive me",
|
|
identifier: "PAP-1",
|
|
status: "todo" as const,
|
|
hiddenAt: null,
|
|
updatedAt: new Date(1),
|
|
};
|
|
recordRecentTask(issue, "user-1");
|
|
mockIssuesApi.get.mockResolvedValue(issue);
|
|
mockIssuesApi.archiveFromInbox.mockResolvedValue({
|
|
id: issue.id,
|
|
archivedAt: new Date(2),
|
|
});
|
|
|
|
await render();
|
|
await openActions("Archive me");
|
|
await act(async () => {
|
|
menuItem("Archive")?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
|
|
await Promise.resolve();
|
|
await new Promise((resolve) => window.setTimeout(resolve, 0));
|
|
});
|
|
|
|
expect(mockIssuesApi.archiveFromInbox).toHaveBeenCalledWith("issue-1");
|
|
expect(mockIssuesApi.update).not.toHaveBeenCalled();
|
|
expect(container.textContent).toContain("Recent Tasks");
|
|
expect(container.querySelector('a[href="/issues/PAP-1"]')?.textContent).toContain(
|
|
"Archive me",
|
|
);
|
|
expect(readRecentTasks(
|
|
getRecentTasksStorageKey("company-1", "user-1"),
|
|
"company-1",
|
|
)).toHaveLength(1);
|
|
});
|
|
|
|
it("refreshes task activity after a rename", async () => {
|
|
const issue = {
|
|
id: "issue-1",
|
|
companyId: "company-1",
|
|
title: "Old title",
|
|
identifier: "PAP-1",
|
|
status: "todo" as const,
|
|
hiddenAt: null,
|
|
updatedAt: new Date(1),
|
|
};
|
|
const renamedIssue = { ...issue, title: "New title", updatedAt: new Date(2) };
|
|
recordRecentTask(issue, "user-1");
|
|
mockIssuesApi.get.mockResolvedValue(issue);
|
|
mockIssuesApi.update.mockResolvedValue(renamedIssue);
|
|
|
|
const queryClient = await render();
|
|
const invalidateQueries = vi.spyOn(queryClient, "invalidateQueries");
|
|
await openActions("Old title");
|
|
await act(async () => {
|
|
menuItem("Rename")?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
|
|
await Promise.resolve();
|
|
});
|
|
|
|
const input = document.body.querySelector<HTMLInputElement>('input[aria-label="Task name"]');
|
|
expect(input).not.toBeNull();
|
|
await act(async () => {
|
|
setInputValue(input!, "New title");
|
|
await Promise.resolve();
|
|
});
|
|
await act(async () => {
|
|
input?.closest("form")?.dispatchEvent(new SubmitEvent("submit", { bubbles: true, cancelable: true }));
|
|
await Promise.resolve();
|
|
await new Promise((resolve) => window.setTimeout(resolve, 0));
|
|
});
|
|
|
|
expect(mockIssuesApi.update).toHaveBeenCalledWith("issue-1", { title: "New title" });
|
|
expect(invalidateQueries).toHaveBeenCalledWith({
|
|
queryKey: queryKeys.issues.activity("issue-1"),
|
|
});
|
|
});
|
|
|
|
it("pauses a running task or restarts its active pause hold", async () => {
|
|
const issue = {
|
|
id: "issue-1",
|
|
companyId: "company-1",
|
|
title: "Toggle work",
|
|
identifier: "PAP-1",
|
|
status: "in_progress" as const,
|
|
assigneeAgentId: "agent-1",
|
|
hiddenAt: null,
|
|
updatedAt: new Date(1),
|
|
};
|
|
recordRecentTask(issue, "user-1");
|
|
mockIssuesApi.get.mockResolvedValue(issue);
|
|
mockIssuesApi.getTreeControlState
|
|
.mockResolvedValueOnce({ activePauseHold: null })
|
|
.mockResolvedValueOnce({
|
|
activePauseHold: {
|
|
holdId: "hold-1",
|
|
rootIssueId: "issue-1",
|
|
issueId: "issue-1",
|
|
isRoot: true,
|
|
mode: "pause",
|
|
reason: null,
|
|
releasePolicy: { strategy: "manual" },
|
|
},
|
|
});
|
|
mockIssuesApi.createTreeHold.mockResolvedValue({ hold: {}, preview: {} });
|
|
mockIssuesApi.releaseTreeHold.mockResolvedValue({});
|
|
mockAgentsApi.wakeup.mockResolvedValue({ id: "run-1" });
|
|
|
|
await render();
|
|
await openActions("Toggle work");
|
|
await act(async () => {
|
|
menuItem("Pause/Restart")?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
|
|
await Promise.resolve();
|
|
await new Promise((resolve) => window.setTimeout(resolve, 0));
|
|
});
|
|
expect(mockIssuesApi.createTreeHold).toHaveBeenCalledWith("issue-1", {
|
|
mode: "pause",
|
|
reason: "Paused from Recent Tasks.",
|
|
releasePolicy: { strategy: "manual" },
|
|
});
|
|
|
|
await openActions("Toggle work");
|
|
await act(async () => {
|
|
menuItem("Pause/Restart")?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
|
|
await Promise.resolve();
|
|
await new Promise((resolve) => window.setTimeout(resolve, 0));
|
|
});
|
|
expect(mockIssuesApi.releaseTreeHold).toHaveBeenCalledWith("issue-1", "hold-1", {
|
|
reason: "Restarted from Recent Tasks.",
|
|
});
|
|
expect(mockAgentsApi.wakeup).toHaveBeenCalledWith(
|
|
"agent-1",
|
|
{
|
|
source: "assignment",
|
|
triggerDetail: "manual",
|
|
reason: "recent_task_restart",
|
|
payload: { issueId: "issue-1" },
|
|
},
|
|
"company-1",
|
|
);
|
|
});
|
|
|
|
it("retries only the wake after a remount when restart releases the hold before wakeup fails", async () => {
|
|
const issue = {
|
|
id: "issue-1",
|
|
companyId: "company-1",
|
|
title: "Retry restart",
|
|
identifier: "PAP-1",
|
|
status: "in_progress" as const,
|
|
assigneeAgentId: "agent-1",
|
|
hiddenAt: null,
|
|
updatedAt: new Date(1),
|
|
};
|
|
recordRecentTask(issue, "user-1");
|
|
mockIssuesApi.get.mockResolvedValue(issue);
|
|
mockIssuesApi.getTreeControlState
|
|
.mockResolvedValueOnce({
|
|
activePauseHold: {
|
|
holdId: "hold-1",
|
|
rootIssueId: "issue-1",
|
|
issueId: "issue-1",
|
|
isRoot: true,
|
|
mode: "pause",
|
|
reason: null,
|
|
releasePolicy: { strategy: "manual" },
|
|
},
|
|
})
|
|
.mockResolvedValueOnce({ activePauseHold: null });
|
|
mockIssuesApi.releaseTreeHold.mockResolvedValue({});
|
|
mockAgentsApi.wakeup
|
|
.mockRejectedValueOnce(new Error("Wake failed"))
|
|
.mockResolvedValueOnce({ id: "run-1" });
|
|
|
|
await render();
|
|
await openActions("Retry restart");
|
|
await act(async () => {
|
|
menuItem("Pause/Restart")?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
|
|
await Promise.resolve();
|
|
await new Promise((resolve) => window.setTimeout(resolve, 0));
|
|
});
|
|
|
|
await act(async () => root.unmount());
|
|
root = createRoot(container);
|
|
await render();
|
|
|
|
await openActions("Retry restart");
|
|
await act(async () => {
|
|
menuItem("Pause/Restart")?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
|
|
await Promise.resolve();
|
|
await new Promise((resolve) => window.setTimeout(resolve, 0));
|
|
});
|
|
|
|
expect(mockIssuesApi.releaseTreeHold).toHaveBeenCalledTimes(1);
|
|
expect(mockIssuesApi.createTreeHold).not.toHaveBeenCalled();
|
|
expect(mockAgentsApi.wakeup).toHaveBeenCalledTimes(2);
|
|
expect(mockAgentsApi.wakeup).toHaveBeenLastCalledWith(
|
|
"agent-1",
|
|
{
|
|
source: "assignment",
|
|
triggerDetail: "manual",
|
|
reason: "recent_task_restart_retry",
|
|
payload: { issueId: "issue-1" },
|
|
},
|
|
"company-1",
|
|
);
|
|
});
|
|
|
|
it("synchronizes recent tasks written by another tab", async () => {
|
|
mockIssuesApi.get.mockImplementation(() => new Promise(() => {}));
|
|
await render();
|
|
const storageKey = getRecentTasksStorageKey("company-1", "user-1");
|
|
const entries = [{
|
|
id: "issue-2",
|
|
companyId: "company-1",
|
|
title: "Cross-tab task",
|
|
identifier: "PAP-2",
|
|
status: "todo" as const,
|
|
recordedAt: 2,
|
|
}];
|
|
|
|
await act(async () => {
|
|
window.localStorage.setItem(storageKey, JSON.stringify(entries));
|
|
window.dispatchEvent(new StorageEvent("storage", { key: storageKey }));
|
|
await Promise.resolve();
|
|
});
|
|
|
|
expect(container.querySelector('a[href="/issues/PAP-2"]')?.textContent).toContain("Cross-tab task");
|
|
});
|
|
|
|
it("preserves pending restart wake retries from before the snapshot storage migration", async () => {
|
|
const issue = {
|
|
id: "issue-1", companyId: "company-1", title: "Retry after upgrade", identifier: "PAP-1",
|
|
status: "in_progress" as const, assigneeAgentId: "agent-1", hiddenAt: null, updatedAt: new Date(1),
|
|
};
|
|
window.localStorage.setItem("paperclip.recentTasks:company-1:user-1", JSON.stringify([{ ...issue, recordedAt: 1 }]));
|
|
window.localStorage.setItem("paperclip.recentTasks:company-1:user-1:restart-wake-retry", JSON.stringify([issue.id]));
|
|
mockIssuesApi.get.mockResolvedValue(issue);
|
|
mockIssuesApi.getTreeControlState.mockResolvedValue({ activePauseHold: null });
|
|
mockAgentsApi.wakeup.mockResolvedValue({ id: "run-1" });
|
|
|
|
await render();
|
|
await openActions("Retry after upgrade");
|
|
await act(async () => {
|
|
menuItem("Pause/Restart")?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
|
|
await Promise.resolve();
|
|
await new Promise((resolve) => window.setTimeout(resolve, 0));
|
|
});
|
|
|
|
expect(mockIssuesApi.createTreeHold).not.toHaveBeenCalled();
|
|
expect(mockIssuesApi.releaseTreeHold).not.toHaveBeenCalled();
|
|
expect(mockAgentsApi.wakeup).toHaveBeenCalledWith("agent-1", expect.objectContaining({
|
|
reason: "recent_task_restart_retry",
|
|
}), "company-1");
|
|
expect(window.localStorage.getItem("paperclip.recentTasks:company-1:user-1:restart-wake-retry")).toBeNull();
|
|
});
|
|
|
|
it("prunes tasks that become hidden", async () => {
|
|
recordRecentTask({
|
|
id: "issue-hidden",
|
|
companyId: "company-1",
|
|
title: "Hidden task",
|
|
identifier: "PAP-3",
|
|
status: "todo",
|
|
updatedAt: new Date(3),
|
|
}, "user-1");
|
|
mockIssuesApi.get.mockResolvedValue({
|
|
id: "issue-hidden",
|
|
companyId: "company-1",
|
|
title: "Hidden task",
|
|
identifier: "PAP-3",
|
|
status: "todo",
|
|
hiddenAt: new Date(),
|
|
updatedAt: new Date(4),
|
|
});
|
|
|
|
await render();
|
|
await act(async () => {
|
|
await Promise.resolve();
|
|
await new Promise((resolve) => window.setTimeout(resolve, 0));
|
|
});
|
|
|
|
expect(container.querySelector('a[href="/issues/PAP-3"]')).toBeNull();
|
|
expect(readRecentTasks(
|
|
getRecentTasksStorageKey("company-1", "user-1"),
|
|
"company-1",
|
|
)).toEqual([]);
|
|
});
|
|
});
|