mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-04 19:28:46 +01:00
fix(ui): expose governed retained-file recovery (#18848)
## Thinking Path > - Paperclip is the open source app people use to manage AI agents for work. > - The control plane must preserve saved work before it admits another attempt. > - Retained-file recovery already has an authorized API and a bounded worker. > - The task UI hid that operation when workspace repair blocked execution. > - The run inspector could check source identity but could not request preservation. > - This pull request exposes that existing operation with its exact source binding. > - The worker still owns file verification, stop receipts, and execution release. ## Linked Issues or Issue Description Refs #18678 and #18803 for the existing retained-source and continuation contracts. **What happened?** A failed native run could leave an active, system-owned export recovery action. The task showed a generic Retry control. Its workspace repair gate correctly refused another provider turn. The run inspector offered only read-only source inspection. The authorized file-preservation API had no production UI caller. **Expected behavior** An authorized board operator can request preservation of the exact retained files. The UI keeps the repair hold until the server records verified preservation. A lost response must keep the same request identity. **Steps to reproduce** 1. Use an active retained-export action whose workspace recovery is blocked and retryable. 2. Open its source task while `workspaceRepairRequired` is true. 3. Open the exact failed run and inspect recovery. 4. Before this change, neither surface can request the existing file-preservation operation. **Paperclip version or commit** The focused regression fails on master `1f55073f96b2485f49f98ee8c261aa14ec2f79ac` before the production UI edits. I checked the roadmap and searched open public PRs for this UI repair. No duplicate was found. This is a repair to the existing recovery capability. ## What Changed - Add Recover saved files to the existing task recovery area and exact-run inspector. Reuse the current board task-mutation access check and the existing `recoverWorkspace` API. - Read the exact action, run, company, task, and source observation again before sending. Refuse changed, retired, foreign, unverified, or non-retryable sources. - Save one account-scoped request before POST. Keep its key through a lost response and reload. Reconcile with GET before an explicit resend. Use a new key only after an explicit click and a fresh, confirmed exhausted attempt; do not resend automatically. - Show queued, recovering, blocked, and verified receipt states separately. A request acknowledgement does not mark files saved or resolve the task hold. Hide generic Retry for native export holds. Keep the existing Retry path for legacy restoration. - Cover both mounted surfaces and negative access, source, account, persistence, duplicate-click, and lost-response cases. Update the existing design guidance and correct the affected run-detail recipe only. ## Verification - RED: the new component regression fails with `missing Recover saved files` before production changes. The original failure is retained. - GREEN: 265 tests pass across `WorkspaceExportRecovery.control.test.tsx`, `WorkspaceExportRecovery.test.tsx`, `RunWorkspaceRecoverySurface.test.tsx`, and the full `IssueDetail.test.tsx` suite. - Review RED/GREEN: the prior UI reused the failed key after a confirmed exhausted attempt. A focused regression now proves a different key for an explicit new attempt, while the lost-response controls still prove key reuse. Mounted task controls prove that verified native preservation stays available, unverified or stale native sources never offer generic Retry, and viewers cannot mutate. A separate RED against the exact prior UI proves the lost legacy control. Its GREEN clicks the existing legacy Retry API while the workspace hold remains active. - Full UI TypeScript check passes: `node scripts/run-tsc.mjs -p ui/tsconfig.json --noEmit`. - `node scripts/check-token-gates.mjs`, `node scripts/check-maps.mjs`, and `git diff --check` pass. The map check proves structure only. - One early legacy test probe used an unsigned fixture and a readonly array; those setup failures are retained. The corrected same-user fixture proves the source RED and GREEN. The first test command used an unnamed project filter and stopped before loading tests. The corrected package configuration produced the recorded RED. One initial storage fault probe did not intercept jsdom's storage method; the corrected prototype fault proves that unavailable storage sends no POST. - Dependencies use Node 24.22.2 and a frozen pnpm 9.15.4 install with scripts disabled. The maintained shared and SDK prerequisite builds pass on this base. No dependency or lockfile changes are included. - A later Paperclip Review follow-up found the plain-HTTP UUID gap. Its focused regression fails before POST with the prior direct call, then passes with the existing UUID helper. The same storage, lost-response, retry and source controls remain green. - Original full CI `41715060582` fails two Cloud-auth task-entry browser checks at their existing heading assertion. The retained original artifacts show a late task pane (one already contains the heading; one still shows Loading conversation). The cause remains unproven. No auth, fixture, timeout or assertion change is included. Fresh Greptile is 5/5 with zero open threads and Paperclip Review passes on the UUID fix head. Current full CI `41720068249` attempt 1 failed. Three workers were terminated by AWS Spot capacity loss. The CLI startup and dense-ZIP checks also timed out at their unchanged deadlines. The CLI/shared input trees match a previous passing CI job, and the dense-ZIP case passes one focused local check. The CLI timeout cause remains unknown. The coordinator requested one bounded recheck. Attempt 2 succeeds on the same source, with all current checks green. No source, fixture, timeout or assertion changed for that recheck. The worker issued no retry. This pass does not establish the original CLI timeout cause. - Full recursive typecheck, repository tests, and application build were not run locally under the bounded UI verification scope. Full CI is requested. - No live preservation request, provider turn, deployment, or sandbox cleanup was performed for this repair. Original saved-file recovery remains unverified until rollout and real acceptance. ## Risks The client access check is a display guard. The existing server authorization and physical source, ownership, stop, and snapshot checks remain authoritative. Unavailable browser storage blocks the request before POST. A failed acknowledgement retains the request for its owner. The UI never calls task Retry, recovery resolution, reconstruction, provider execution, or destructive cleanup. The existing worker retains its bounded recovery policy and may finish the saved result after real preservation. ## Model Used OpenAI Codex, GPT-6 family, with repository inspection, code editing, and test execution. The exact runtime model ID and context-window size are not exposed to this agent. ## 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 - [x] All Paperclip CI gates are green - [x] Greptile is 5/5 with no open P2s, recommendations, or follow-ups - [x] I will address all Greptile and reviewer comments before requesting merge --------- Co-authored-by: Paperclip <noreply@paperclip.ing>
This commit is contained in:
DottaandPaperclip authored and GitHub committed
1 parent
f187de99aa
commit
519b345d69
10 files changed
+574
-31
No files matched your search
@@ -299,7 +299,9 @@ tests this host; it is component coverage, not an end-to-end repair.
|
||||
|
||||
Manual: prepare a failed run with error code `workspace_validation_failed`, a
|
||||
linked source task, and a live `workspace_validation` recovery action on that
|
||||
task. Open that exact run and compare its recovery diagnosis to the source task.
|
||||
task. For retained-file export recovery, use a matching active source action and
|
||||
terminal run; compare Recover saved files on the task and run inspector.
|
||||
Open that exact run and compare its recovery diagnosis to the source task.
|
||||
Use an eligible action from the run surface, return to the task,
|
||||
and verify the same action state, persisted outcome, and restored execution.
|
||||
Repeat with an actor who lacks authority. Verify that the run-page controls are
|
||||
|
||||
@@ -16,6 +16,7 @@ const resolveRecoveryMock = vi.hoisted(() => vi.fn());
|
||||
const reconcileMock = vi.hoisted(() => vi.fn());
|
||||
const boardAccessMock = vi.hoisted(() => vi.fn());
|
||||
const recoveryActionsMock = vi.hoisted(() => vi.fn());
|
||||
const recoverWorkspaceMock = vi.hoisted(() => vi.fn());
|
||||
|
||||
vi.mock("@/lib/router", () => ({
|
||||
useNavigate: () => navigateMock,
|
||||
@@ -30,6 +31,7 @@ vi.mock("../api/issues", () => ({
|
||||
create: issueCreateMock,
|
||||
resolveRecoveryAction: resolveRecoveryMock,
|
||||
recoveryActions: recoveryActionsMock,
|
||||
recoverWorkspace: recoverWorkspaceMock,
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -151,10 +153,11 @@ function buildIssue(action: IssueRecoveryAction | null): Issue {
|
||||
} as unknown as Issue;
|
||||
}
|
||||
|
||||
async function renderSurface(run: HeartbeatRun) {
|
||||
async function renderSurface(run: HeartbeatRun, viewerId?: string) {
|
||||
const client = new QueryClient({
|
||||
defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
|
||||
});
|
||||
if (viewerId) client.setQueryData(["auth", "session"], { user: { id: viewerId } });
|
||||
container = document.createElement("div");
|
||||
document.body.appendChild(container);
|
||||
root = createRoot(container);
|
||||
@@ -278,6 +281,34 @@ describe("RunWorkspaceRecoverySurface", () => {
|
||||
expect(choices()).toHaveLength(2);
|
||||
});
|
||||
|
||||
it("offers the same governed file preservation from the exact failed run without resolving its hold", async () => {
|
||||
const run = buildRun({ errorCode: "native_workspace_sync_out_retry_exhausted" });
|
||||
const action = { ...buildRecoveryAction(), kind: "active_run_watchdog", ownerType: "system",
|
||||
cause: "native_workspace_sync_out_retry_exhausted", evidence: { runId: run.id, workspaceRecovery: {
|
||||
schema: "paperclip.workspace-recovery.v1", runId: run.id, status: "blocked",
|
||||
stage: "restoring_files", retryable: true, requestIds: [],
|
||||
}, systemRecovery: { state: "exhausted", preservationOperationIds: [] } } } as IssueRecoveryAction;
|
||||
boardAccessMock.mockResolvedValue({ source: "session", companyIds: ["company-1"], userId: "run-operator",
|
||||
memberships: [{ companyId: "company-1", membershipRole: "operator", status: "active" }] });
|
||||
recoveryActionsMock.mockResolvedValue({ active: action, actions: [action], sourceInspection: {
|
||||
actionId: action.id, runId: run.id, scope: "recorded_source_identity", status: "verified",
|
||||
observedAt: "2026-11-03T12:00:00Z",
|
||||
} });
|
||||
recoverWorkspaceMock.mockResolvedValue({ actionId: action.id, status: "queued" });
|
||||
const node = await renderSurface(run, "run-operator");
|
||||
click([...node.querySelectorAll("button")].find(button => button.textContent === "Inspect recovery")!);
|
||||
await flush();
|
||||
const preserve = [...node.querySelectorAll("button")].find(button => button.textContent === "Recover saved files");
|
||||
expect(preserve).toBeDefined();
|
||||
click(preserve!); await flush();
|
||||
expect(recoverWorkspaceMock).toHaveBeenCalledExactlyOnceWith("issue-1", {
|
||||
actionId: action.id, runId: run.id, idempotencyKey: expect.any(String),
|
||||
});
|
||||
expect(resolveRecoveryMock).not.toHaveBeenCalled();
|
||||
expect(issueCreateMock).not.toHaveBeenCalled();
|
||||
expect(node.textContent).not.toContain("Saved files recovered");
|
||||
});
|
||||
|
||||
it("renders nothing for a run that is not a workspace-validation failure", async () => {
|
||||
issueGetMock.mockResolvedValue(buildIssue(buildRecoveryAction()));
|
||||
boardAccessMock.mockResolvedValue(undefined);
|
||||
|
||||
@@ -57,7 +57,7 @@ export function RunWorkspaceRecoverySurface({ run }: { run: HeartbeatRun }) {
|
||||
const issueId = readRunIssueId(run);
|
||||
const cause = run.execution?.cause ?? run.errorCode;
|
||||
if (issueId && (isNativeWorkspaceExportRepairCause(cause) || cause === "native_workspace_sync_out_unrecoverable"))
|
||||
return <RunWorkspaceSourceInspection key={run.id} issueId={issueId} runId={run.id} />;
|
||||
return <RunWorkspaceSourceInspection key={run.id} issueId={issueId} runId={run.id} companyId={run.companyId} />;
|
||||
return <WorkspaceValidationRecoverySurface run={run} />;
|
||||
}
|
||||
|
||||
|
||||
@@ -3,6 +3,7 @@ import { ENVIRONMENT_LEASE_POLICIES, WORKSPACE_SOURCE_VERIFICATION_REASONS } fro
|
||||
import { issuesApi } from "../api/issues";
|
||||
import { Button } from "./ui/button";
|
||||
import { formatDateTime } from "../lib/utils";
|
||||
import { WorkspaceExportRecovery } from "./WorkspaceExportRecovery";
|
||||
|
||||
function recordedFailure(evidence: Record<string, unknown>): string {
|
||||
const recovery = evidence.systemRecovery;
|
||||
@@ -19,7 +20,7 @@ function recordedFailure(evidence: Record<string, unknown>): string {
|
||||
return [failure.code, detail.reason, ...(allowedPolicy ? [`lease policy ${policy}`] : [])].join(" · ");
|
||||
}
|
||||
|
||||
export function RunWorkspaceSourceInspection({ issueId, runId }: { issueId: string; runId: string }) {
|
||||
export function RunWorkspaceSourceInspection({ issueId, runId, companyId }: { issueId: string; runId: string; companyId: string }) {
|
||||
const listing = useMutation({ mutationFn: () => issuesApi.recoveryActions(issueId, { runId }) });
|
||||
const inspection = useMutation({ mutationFn: (actionId: string) => issuesApi.recoveryActions(issueId, { runId, actionId }) });
|
||||
const pending = listing.isPending || inspection.isPending;
|
||||
@@ -41,6 +42,8 @@ export function RunWorkspaceSourceInspection({ issueId, runId }: { issueId: stri
|
||||
<Button variant="ghost" size="sm" disabled={pending} onClick={() => inspection.mutate(action.id)}>
|
||||
Inspect current source
|
||||
</Button>
|
||||
{action.evidence.runId === runId ? <WorkspaceExportRecovery action={action}
|
||||
issueId={issueId} companyId={companyId} showStatus={false} /> : null}
|
||||
</div>
|
||||
))}
|
||||
{current ? <div className="space-y-2 text-xs" role="status">
|
||||
|
||||
@@ -0,0 +1,261 @@
|
||||
// @vitest-environment jsdom
|
||||
import { act } 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 type { IssueRecoveryAction } from "@paperclipai/shared";
|
||||
import { queryKeys } from "../lib/queryKeys";
|
||||
import { WorkspaceExportRecovery } from "./WorkspaceExportRecovery";
|
||||
|
||||
const api = vi.hoisted(() => ({ inspect: vi.fn(), recover: vi.fn() }));
|
||||
vi.mock("../api/issues", () => ({ issuesApi: { recoveryActions: api.inspect, recoverWorkspace: api.recover } }));
|
||||
(globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
|
||||
|
||||
const action = {
|
||||
id: "action-1", companyId: "company-1", sourceIssueId: "issue-1",
|
||||
cause: "native_workspace_sync_out_retry_exhausted", kind: "active_run_watchdog",
|
||||
status: "active", ownerType: "system", wakePolicy: null,
|
||||
evidence: { runId: "run-1", workspaceRecovery: {
|
||||
schema: "paperclip.workspace-recovery.v1", runId: "run-1", status: "blocked",
|
||||
stage: "restoring_files", attempt: 6, requestIds: [], retryable: true,
|
||||
}, systemRecovery: { state: "exhausted", preservationOperationIds: [] } },
|
||||
} as unknown as IssueRecoveryAction;
|
||||
|
||||
function inspection(value = action) {
|
||||
return { active: value, actions: [value], sourceInspection: {
|
||||
schema: "paperclip.workspace-source-inspection.v1", actionId: value.id, runId: "run-1",
|
||||
status: "verified", scope: "recorded_source_identity", observedAt: "2026-11-03T12:00:00Z",
|
||||
} };
|
||||
}
|
||||
|
||||
describe("governed retained-file recovery", () => {
|
||||
let root: Root, container: HTMLDivElement, client: QueryClient;
|
||||
beforeEach(() => {
|
||||
vi.resetAllMocks(); localStorage.clear();
|
||||
api.inspect.mockResolvedValue(inspection());
|
||||
api.recover.mockResolvedValue({ actionId: action.id, status: "queued" });
|
||||
client = new QueryClient({ defaultOptions: { queries: { retry: false, staleTime: Infinity }, mutations: { retry: false } } });
|
||||
client.setQueryData(queryKeys.auth.session, { user: { id: "board-1" } });
|
||||
client.setQueryData(queryKeys.access.currentBoardAccess, {
|
||||
userId: "board-1", companyIds: ["company-1"], source: "session", isInstanceAdmin: false,
|
||||
memberships: [{ companyId: "company-1", membershipRole: "operator", status: "active" }],
|
||||
});
|
||||
container = document.createElement("div"); document.body.append(container); root = createRoot(container);
|
||||
});
|
||||
afterEach(async () => {
|
||||
await act(async () => root.unmount()); container.remove(); client.clear(); localStorage.clear();
|
||||
vi.restoreAllMocks();
|
||||
});
|
||||
async function mount(value: IssueRecoveryAction | null = action) {
|
||||
const props = { action: value, issueId: "issue-1", companyId: "company-1" };
|
||||
await act(async () => root.render(<QueryClientProvider client={client}>
|
||||
<WorkspaceExportRecovery {...props} />
|
||||
</QueryClientProvider>));
|
||||
await settle();
|
||||
}
|
||||
async function settle() {
|
||||
await act(async () => { await new Promise(resolve => setTimeout(resolve, 0)); });
|
||||
}
|
||||
function button(label: string) { return [...container.querySelectorAll("button")].find(b => b.textContent === label); }
|
||||
async function click(label: string) {
|
||||
const target = button(label); expect(target, `missing ${label}`).toBeDefined();
|
||||
await act(async () => target!.click()); await settle();
|
||||
}
|
||||
|
||||
it("offers the existing preservation operation for a stopped, exhausted system-owned export", async () => {
|
||||
await mount();
|
||||
await click("Recover saved files");
|
||||
expect(api.inspect).toHaveBeenCalledWith("issue-1", { runId: "run-1", actionId: "action-1" });
|
||||
expect(api.recover).toHaveBeenCalledTimes(1);
|
||||
expect(api.recover).toHaveBeenCalledWith("issue-1", {
|
||||
actionId: "action-1", runId: "run-1", idempotencyKey: expect.any(String),
|
||||
});
|
||||
expect(container.textContent).toContain("queued");
|
||||
expect(container.textContent).not.toContain("Saved files recovered");
|
||||
});
|
||||
|
||||
it("requests file preservation on plain HTTP without crypto.randomUUID", async () => {
|
||||
const originalCrypto = globalThis.crypto;
|
||||
vi.stubGlobal("crypto", { getRandomValues: originalCrypto.getRandomValues.bind(originalCrypto) });
|
||||
try {
|
||||
await mount(); await click("Recover saved files");
|
||||
expect(api.recover).toHaveBeenCalledExactlyOnceWith("issue-1", {
|
||||
actionId: "action-1", runId: "run-1", idempotencyKey: expect.stringMatching(
|
||||
/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/),
|
||||
});
|
||||
expect(container.textContent).not.toContain("Saved files recovered");
|
||||
} finally { vi.unstubAllGlobals(); }
|
||||
});
|
||||
|
||||
it.each(["viewer", "suspended", "foreign-company", "other-account"])("does not offer mutation with %s access", async kind => {
|
||||
client.setQueryData(queryKeys.access.currentBoardAccess, {
|
||||
userId: kind === "other-account" ? "board-2" : "board-1", source: "session", isInstanceAdmin: false,
|
||||
companyIds: kind === "foreign-company" ? ["company-2"] : ["company-1"],
|
||||
memberships: [{ companyId: kind === "foreign-company" ? "company-2" : "company-1",
|
||||
membershipRole: kind === "viewer" ? "viewer" : "operator", status: kind === "suspended" ? "suspended" : "active" }],
|
||||
});
|
||||
await mount();
|
||||
expect(button("Recover saved files")).toBeUndefined();
|
||||
expect(api.inspect).not.toHaveBeenCalled();
|
||||
expect(api.recover).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it.each(["resolved", "cancelled", "foreign-company", "foreign-task", "unsafe-archive"])("does not offer a %s source", async kind => {
|
||||
await mount({ ...action, ...(kind === "foreign-company" ? { companyId: "company-2" }
|
||||
: kind === "foreign-task" ? { sourceIssueId: "issue-2" }
|
||||
: kind === "unsafe-archive" ? { cause: "native_workspace_sync_out_unsafe_archive" }
|
||||
: { status: kind }) } as IssueRecoveryAction);
|
||||
expect(button("Recover saved files")).toBeUndefined();
|
||||
expect(api.recover).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("rejects a source/action/run binding that changed after the control was rendered", async () => {
|
||||
api.inspect.mockResolvedValueOnce(inspection()).mockResolvedValueOnce({
|
||||
...inspection(), sourceInspection: { ...inspection().sourceInspection, runId: "foreign-run" },
|
||||
});
|
||||
await mount(); await click("Recover saved files");
|
||||
expect(api.recover).not.toHaveBeenCalled();
|
||||
expect(container.textContent).toContain("File recovery changed");
|
||||
});
|
||||
|
||||
it("does not offer an unverified source", async () => {
|
||||
api.inspect.mockResolvedValue({ ...inspection(), sourceInspection: {
|
||||
...inspection().sourceInspection, status: "blocked", failureCode: "source_binding_invalid",
|
||||
} });
|
||||
await mount();
|
||||
expect(button("Recover saved files")).toBeUndefined();
|
||||
expect(container.textContent).toContain("source is unavailable or has changed");
|
||||
});
|
||||
|
||||
it("persists the exact request before POST and prevents a double click", async () => {
|
||||
let finish!: (value: unknown) => void;
|
||||
api.recover.mockImplementation((_issue, body) => {
|
||||
expect(localStorage.getItem("workspace-file-recovery:company-1:issue-1:action-1:run-1:board-1")).toContain(body.idempotencyKey);
|
||||
return new Promise(resolve => { finish = resolve; });
|
||||
});
|
||||
await mount();
|
||||
const target = button("Recover saved files")!;
|
||||
await act(async () => { target.click(); target.click(); }); await settle();
|
||||
expect(api.recover).toHaveBeenCalledTimes(1);
|
||||
await act(async () => finish({ actionId: action.id, status: "queued" })); await settle();
|
||||
expect(button("Recover saved files")).toBeUndefined();
|
||||
expect(container.textContent).not.toContain("Saved files recovered");
|
||||
});
|
||||
|
||||
it("reconciles a lost accepted response through GET without another POST", async () => {
|
||||
let current = action;
|
||||
api.inspect.mockImplementation(async () => inspection(current));
|
||||
api.recover.mockImplementation(async (_issue, body) => {
|
||||
current = { ...action, evidence: { ...action.evidence, workspaceRecovery: {
|
||||
...(action.evidence.workspaceRecovery as object), status: "queued", requestIds: [body.idempotencyKey],
|
||||
} } };
|
||||
throw Object.assign(new Error("Network reply lost"), { status: 503 });
|
||||
});
|
||||
await mount(); await click("Recover saved files");
|
||||
expect(container.textContent).toContain("could not be confirmed");
|
||||
await click("Check file recovery status");
|
||||
expect(api.recover).toHaveBeenCalledTimes(1);
|
||||
expect(container.textContent).toContain("Recovering saved files");
|
||||
expect(container.textContent).not.toContain("could not be confirmed");
|
||||
expect(button("Recover saved files")).toBeUndefined();
|
||||
});
|
||||
|
||||
it("reuses the stored key after remount and a GET that has no acceptance receipt", async () => {
|
||||
api.recover.mockRejectedValueOnce(Object.assign(new Error("Network unavailable"), { status: 503 }));
|
||||
await mount(); await click("Recover saved files");
|
||||
const first = api.recover.mock.calls[0][1].idempotencyKey;
|
||||
await act(async () => root.render(null));
|
||||
await mount();
|
||||
expect(button("Recover saved files")).toBeUndefined();
|
||||
await click("Check file recovery status");
|
||||
await click("Recover saved files");
|
||||
expect(api.recover).toHaveBeenCalledTimes(2);
|
||||
expect(api.recover.mock.calls[1][1].idempotencyKey).toBe(first);
|
||||
});
|
||||
|
||||
it("does not POST when durable storage is unavailable", async () => {
|
||||
vi.spyOn(Storage.prototype, "setItem").mockImplementation(() => { throw new Error("storage denied"); });
|
||||
await mount(); await click("Recover saved files");
|
||||
expect(api.recover).not.toHaveBeenCalled();
|
||||
expect(container.textContent).toContain("No request was sent");
|
||||
});
|
||||
|
||||
it("does not send an old account's request after a source read completes", async () => {
|
||||
let finish!: (value: unknown) => void;
|
||||
api.inspect.mockResolvedValueOnce(inspection()).mockImplementationOnce(() => new Promise(resolve => { finish = resolve; }));
|
||||
await mount(); await click("Recover saved files");
|
||||
await act(async () => client.setQueryData(queryKeys.auth.session, { user: { id: "board-2" } }));
|
||||
await act(async () => finish(inspection())); await settle();
|
||||
expect(api.recover).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("shows a confirmed blocked attempt as failed preservation, not queued or recovered", async () => {
|
||||
let current = action;
|
||||
api.inspect.mockImplementation(async () => inspection(current));
|
||||
api.recover.mockImplementation(async (_issue, body) => {
|
||||
current = { ...action, evidence: { ...action.evidence, workspaceRecovery: {
|
||||
...(action.evidence.workspaceRecovery as object), requestIds: [body.idempotencyKey],
|
||||
} } };
|
||||
return { actionId: action.id, status: "queued" };
|
||||
});
|
||||
await mount(); await click("Recover saved files");
|
||||
expect(container.textContent).toContain("File recovery has not finished");
|
||||
expect(container.textContent).not.toContain("File recovery is queued");
|
||||
expect(container.textContent).not.toContain("Saved files recovered");
|
||||
expect(api.recover).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it("offers a new explicit request only after the prior accepted attempt is confirmed exhausted", async () => {
|
||||
let current = action;
|
||||
const accepted: string[] = [];
|
||||
api.inspect.mockImplementation(async () => inspection(current));
|
||||
api.recover.mockImplementation(async (_issue, body) => {
|
||||
accepted.push(body.idempotencyKey);
|
||||
current = { ...action, evidence: { ...action.evidence, workspaceRecovery: {
|
||||
...(action.evidence.workspaceRecovery as object), requestIds: [...accepted],
|
||||
} } };
|
||||
return { actionId: action.id, status: "queued" };
|
||||
});
|
||||
await mount(); await click("Recover saved files");
|
||||
expect(container.textContent).toContain("File recovery has not finished");
|
||||
expect(api.recover).toHaveBeenCalledTimes(1);
|
||||
await click("Try file recovery again");
|
||||
expect(api.recover).toHaveBeenCalledTimes(2);
|
||||
expect(accepted[1]).not.toBe(accepted[0]);
|
||||
expect(container.textContent).not.toContain("Saved files recovered");
|
||||
});
|
||||
|
||||
it("does not replace the confirmed failed key if another recovery is active at the fresh read", async () => {
|
||||
let current = action;
|
||||
api.inspect.mockImplementation(async () => inspection(current));
|
||||
api.recover.mockImplementation(async (_issue, body) => {
|
||||
current = { ...action, evidence: { ...action.evidence, workspaceRecovery: {
|
||||
...(action.evidence.workspaceRecovery as object), requestIds: [body.idempotencyKey],
|
||||
} } };
|
||||
return { actionId: action.id, status: "queued" };
|
||||
});
|
||||
await mount(); await click("Recover saved files");
|
||||
const previous = api.recover.mock.calls[0][1].idempotencyKey;
|
||||
current = { ...current, evidence: { ...current.evidence, workspaceRecovery: {
|
||||
...(current.evidence.workspaceRecovery as object), status: "recovering",
|
||||
} } };
|
||||
await click("Try file recovery again");
|
||||
expect(api.recover).toHaveBeenCalledTimes(1);
|
||||
expect(localStorage.getItem("workspace-file-recovery:company-1:issue-1:action-1:run-1:board-1")).toContain(previous);
|
||||
});
|
||||
|
||||
it("only reports recovered files after the durable preservation receipt is present", async () => {
|
||||
const recovered = { ...action, evidence: { ...action.evidence, workspaceRecovery: {
|
||||
...(action.evidence.workspaceRecovery as object), status: "recovered",
|
||||
}, systemRecovery: { state: "complete", preservationOperationIds: [] } } };
|
||||
api.inspect.mockResolvedValue(inspection(recovered)); await mount();
|
||||
expect(container.textContent).not.toContain("Saved files recovered");
|
||||
api.inspect.mockResolvedValue(inspection({ ...recovered, evidence: { ...recovered.evidence,
|
||||
systemRecovery: { state: "complete", preservationOperationIds: ["host-preservation-operation"] },
|
||||
} }));
|
||||
await act(async () => client.invalidateQueries({ queryKey: queryKeys.issues.recoveryActions("issue-1", "action-1", "run-1") }));
|
||||
await settle();
|
||||
expect(container.textContent).toContain("Saved files recovered");
|
||||
expect(api.recover).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
@@ -1,11 +1,26 @@
|
||||
import { useRef, useState } from "react";
|
||||
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
|
||||
import type { IssueRecoveryAction } from "@paperclipai/shared";
|
||||
import { isNativeWorkspaceExportRepairCause } from "@paperclipai/shared";
|
||||
import { accessApi } from "../api/access";
|
||||
import { issuesApi } from "../api/issues";
|
||||
import { useDraftOwner, useDraftOwnerReader } from "../hooks/useDraftOwner";
|
||||
import { canBoardResolveRecoveryAction, isRetainedWorkspaceExportCause } from "../lib/recovery-reconcile";
|
||||
import { queryKeys } from "../lib/queryKeys";
|
||||
import { classifySendFailure, pendingSendKeyFor, readPendingSend, writePendingSend } from "../lib/pending-send";
|
||||
import { asObject, cn } from "../lib/utils";
|
||||
import { createUuid } from "../lib/uuid";
|
||||
import { Button } from "./ui/button";
|
||||
|
||||
/** Infrastructure repair belongs to the harness/operator, never a task form. */
|
||||
export function WorkspaceExportRecovery({ action, className }: {
|
||||
className?: string; action: IssueRecoveryAction | null;
|
||||
/** Requests preservation; the existing worker owns stop, copyback and verification. */
|
||||
export function WorkspaceExportRecovery({ action, className, issueId, companyId, showStatus = true }: {
|
||||
className?: string; action: IssueRecoveryAction | null; issueId?: string; companyId?: string; showStatus?: boolean;
|
||||
}) {
|
||||
if (action && issueId && companyId && isRetainedExport(action, issueId, companyId)) {
|
||||
return <RetainedFilesRecovery key={`${companyId}:${issueId}:${action.id}:${action.evidence.runId}`}
|
||||
action={action} issueId={issueId} companyId={companyId} className={className} />;
|
||||
}
|
||||
if (!showStatus) return null;
|
||||
const ownerRecovery = action?.cause === "native_workspace_finalization_owner_unverified";
|
||||
if (!action || (!ownerRecovery && !isNativeWorkspaceExportRepairCause(action.cause)) || action.ownerType !== "board"
|
||||
|| !["active", "escalated"].includes(action.status) || typeof action.evidence.runId !== "string") return null;
|
||||
@@ -15,3 +30,146 @@ export function WorkspaceExportRecovery({ action, className }: {
|
||||
{automatic ? "Restoring saved work…" : "Workspace recovery needs operator assistance. The agent’s result is saved."}
|
||||
</p>;
|
||||
}
|
||||
|
||||
function isRetainedExport(action: IssueRecoveryAction, issueId: string, companyId: string) {
|
||||
return action.companyId === companyId && action.sourceIssueId === issueId
|
||||
&& action.kind === "active_run_watchdog" && ["active", "escalated"].includes(action.status)
|
||||
&& ["board", "system"].includes(action.ownerType)
|
||||
&& isRetainedWorkspaceExportCause(action.cause)
|
||||
&& typeof action.evidence.runId === "string" && action.evidence.runId.length > 0;
|
||||
}
|
||||
|
||||
type RecoveryInput = { actionId: string; runId: string };
|
||||
|
||||
function RetainedFilesRecovery({ action, issueId, companyId, className }: {
|
||||
action: IssueRecoveryAction; issueId: string; companyId: string; className?: string;
|
||||
}) {
|
||||
const runId = action.evidence.runId as string;
|
||||
const owner = useDraftOwner();
|
||||
const readOwner = useDraftOwnerReader();
|
||||
const client = useQueryClient();
|
||||
const busy = useRef(false);
|
||||
const [acknowledged, setAcknowledged] = useState(false);
|
||||
const [checkedUnconfirmed, setCheckedUnconfirmed] = useState(false);
|
||||
const [notice, setNotice] = useState<string | null>(null);
|
||||
const access = useQuery({ queryKey: queryKeys.access.currentBoardAccess,
|
||||
queryFn: () => accessApi.getCurrentBoardAccess(), retry: false });
|
||||
const canMutate = Boolean(owner && (access.data?.source === "local_implicit"
|
||||
|| owner !== "signed-out" && access.data?.userId === owner)
|
||||
&& canBoardResolveRecoveryAction(companyId, access.data));
|
||||
const source = useQuery({ queryKey: queryKeys.issues.recoveryActions(issueId, action.id, runId),
|
||||
queryFn: () => issuesApi.recoveryActions(issueId, { runId, actionId: action.id }), enabled: canMutate, retry: false });
|
||||
const storageKey = owner ? pendingSendKeyFor(`workspace-file-recovery:${companyId}:${issueId}:${action.id}:${runId}`, owner) : null;
|
||||
const matchesInput = (value: unknown): value is RecoveryInput => {
|
||||
const input = asObject(value);
|
||||
return input.actionId === action.id && input.runId === runId;
|
||||
};
|
||||
const pending = storageKey ? readPendingSend(storageKey, matchesInput) : null;
|
||||
function boundAction(data: typeof source.data) {
|
||||
const current = data?.actions.find(item => item.id === action.id);
|
||||
const inspected = data?.sourceInspection;
|
||||
const state = asObject(current?.evidence.workspaceRecovery);
|
||||
return current && isRetainedExport(current, issueId, companyId) && current.evidence.runId === runId
|
||||
&& state.runId === runId && state.schema === "paperclip.workspace-recovery.v1"
|
||||
&& inspected?.actionId === action.id && inspected.runId === runId && inspected.status === "verified" ? current : null;
|
||||
}
|
||||
const current = boundAction(source.data);
|
||||
const recovery = asObject(current?.evidence.workspaceRecovery);
|
||||
const system = asObject(current?.evidence.systemRecovery);
|
||||
const serverAcknowledged = Boolean(pending && Array.isArray(recovery.requestIds) && recovery.requestIds.includes(pending.idempotencyKey));
|
||||
const restoring = ["queued", "recovering"].includes(String(recovery.status));
|
||||
const saved = recovery.status === "recovered" && system.state === "complete"
|
||||
&& Array.isArray(system.preservationOperationIds) && system.preservationOperationIds.length > 0
|
||||
&& system.preservationOperationIds.every(id => typeof id === "string" && id.length > 0);
|
||||
const retryable = recovery.status === "blocked" && recovery.retryable === true;
|
||||
const invalidate = () => {
|
||||
void client.invalidateQueries({ queryKey: queryKeys.issues.detail(issueId) });
|
||||
void client.invalidateQueries({ queryKey: queryKeys.issues.runs(issueId) });
|
||||
void client.invalidateQueries({ queryKey: queryKeys.runDetail(runId) });
|
||||
};
|
||||
const request = useMutation({ retry: false, mutationFn: async (restartFailedAttempt: boolean) => {
|
||||
if (busy.current) return;
|
||||
busy.current = true;
|
||||
setNotice(null);
|
||||
setCheckedUnconfirmed(false);
|
||||
setAcknowledged(false);
|
||||
try {
|
||||
const observed = await source.refetch();
|
||||
const fresh = boundAction(observed.data);
|
||||
const state = asObject(fresh?.evidence.workspaceRecovery);
|
||||
if (observed.error || !fresh || state.status !== "blocked" || state.retryable !== true)
|
||||
throw new Error("File recovery changed. Inspect its current status before requesting recovery.");
|
||||
if (!canMutate || !owner || readOwner() !== owner || !storageKey)
|
||||
throw new Error("Your account changed. Refresh before requesting file recovery.");
|
||||
const previous = readPendingSend(storageKey, matchesInput);
|
||||
if (restartFailedAttempt && (!previous || !Array.isArray(state.requestIds)
|
||||
|| !state.requestIds.includes(previous.idempotencyKey)
|
||||
|| asObject(fresh.evidence.systemRecovery).state !== "exhausted"))
|
||||
throw new Error("The previous failed recovery is not confirmed. Check its status before trying again.");
|
||||
// Unknown acceptance reuses its identity. A new bounded request requires
|
||||
// an explicit operator click and a freshly confirmed exhausted attempt.
|
||||
const record = (!restartFailedAttempt && previous) || {
|
||||
idempotencyKey: createUuid(), payload: { actionId: action.id, runId }, createdAt: Date.now(),
|
||||
};
|
||||
if (!writePendingSend(storageKey, record))
|
||||
throw new Error("The recovery request could not be saved in this browser. No request was sent.");
|
||||
try {
|
||||
const result = await issuesApi.recoverWorkspace(issueId, { ...record.payload, idempotencyKey: record.idempotencyKey });
|
||||
if (result.actionId !== action.id || !["queued", "recovering", "blocked", "recovered"].includes(result.status))
|
||||
throw new Error("The recovery acknowledgement could not be confirmed.");
|
||||
setAcknowledged(true);
|
||||
setCheckedUnconfirmed(false);
|
||||
invalidate();
|
||||
await source.refetch();
|
||||
} catch (error) {
|
||||
setNotice(classifySendFailure(error) === "rejected"
|
||||
? `Recovery request was not confirmed: ${error instanceof Error ? error.message : "Inspect its status."}`
|
||||
: "The recovery request could not be confirmed. Check its status before trying again; the saved request will be reused.");
|
||||
}
|
||||
} catch (error) {
|
||||
setNotice(error instanceof Error ? error.message : "Unable to inspect file recovery.");
|
||||
} finally { busy.current = false; }
|
||||
} });
|
||||
const check = useMutation({ retry: false, mutationFn: async () => {
|
||||
const observed = await source.refetch();
|
||||
if (observed.error) throw observed.error;
|
||||
const fresh = boundAction(observed.data);
|
||||
if (!fresh) throw new Error("File recovery changed. Refresh the task to inspect the current recovery.");
|
||||
const state = asObject(fresh.evidence.workspaceRecovery);
|
||||
const ids = state.requestIds;
|
||||
const unconfirmed = Boolean(pending && Array.isArray(ids) && !ids.includes(pending.idempotencyKey));
|
||||
setCheckedUnconfirmed(unconfirmed);
|
||||
setNotice(unconfirmed ? "No recovery request is confirmed yet. Trying again will reuse the saved request." : null);
|
||||
invalidate();
|
||||
} });
|
||||
const failedReceipt = serverAcknowledged && recovery.status === "blocked";
|
||||
const confirmedFailedAttempt = failedReceipt && retryable && system.state === "exhausted";
|
||||
const waiting = !failedReceipt && !saved && (restoring || acknowledged || serverAcknowledged);
|
||||
const unconfirmed = Boolean(pending && !acknowledged && !serverAcknowledged);
|
||||
return <div className={cn("flex flex-col gap-2 text-sm", className)} data-testid="retained-file-recovery">
|
||||
<p role="status">{saved ? "Saved files recovered. Task recovery is still being checked."
|
||||
: failedReceipt ? "File recovery has not finished. The saved source remains protected."
|
||||
: restoring ? "Recovering saved files. Work remains paused until recovery is verified."
|
||||
: waiting ? "File recovery is queued. Waiting for verified saved files."
|
||||
: "The saved files need recovery before work can continue."}</p>
|
||||
{canMutate ? <>
|
||||
{current && retryable && !waiting && (!pending || unconfirmed && checkedUnconfirmed || confirmedFailedAttempt) ? <Button variant="outline" size="sm"
|
||||
className="self-start" disabled={request.isPending || check.isPending}
|
||||
onClick={() => request.mutate(confirmedFailedAttempt)}>{request.isPending ? "Requesting file recovery…"
|
||||
: confirmedFailedAttempt ? "Try file recovery again" : "Recover saved files"}</Button> : null}
|
||||
{waiting || unconfirmed || failedReceipt || source.isError || source.data && !current ? <Button variant="ghost" size="sm" className="self-start"
|
||||
disabled={request.isPending || check.isPending} onClick={() => check.mutate()}>
|
||||
{check.isPending ? "Checking file recovery…" : "Check file recovery status"}
|
||||
</Button> : null}
|
||||
{source.isPending ? <p className="text-xs text-muted-foreground">Inspecting the recorded file source…</p> : null}
|
||||
{source.isError || check.isError || notice ? <p role="alert" className="text-sm text-destructive">
|
||||
{notice ?? (check.error instanceof Error ? check.error.message : "File recovery could not be inspected. Check its status again.")}
|
||||
</p> : null}
|
||||
{current && recovery.status === "blocked" && (serverAcknowledged || recovery.retryable !== true)
|
||||
? <p role="alert">File recovery has not finished. The saved source remains protected; service assistance is needed.</p> : null}
|
||||
{source.data && !current ? <p role="alert">The recorded source is unavailable or has changed. Inspect recovery before continuing.</p> : null}
|
||||
</> : access.isError ? <p role="alert" className="text-sm text-destructive">Task access could not be checked. Refresh before requesting file recovery.</p>
|
||||
: access.isPending || !owner ? <p role="status" className="text-xs text-muted-foreground">Checking file recovery access…</p>
|
||||
: <p className="text-xs text-muted-foreground">A board member with task access can request file recovery.</p>}
|
||||
</div>;
|
||||
}
|
||||
@@ -34,6 +34,14 @@ export function canBoardManageRuntime(
|
||||
return membership.membershipRole !== "viewer" && membership.membershipRole !== null;
|
||||
}
|
||||
|
||||
/** Client affordance for board task mutations; the server rechecks issue access. */
|
||||
export const canBoardResolveRecoveryAction = canBoardManageRuntime;
|
||||
|
||||
/** Classifies the native export hold, independently of source or actor readiness. */
|
||||
export function isRetainedWorkspaceExportCause(cause: unknown): boolean {
|
||||
return cause === "native_workspace_sync_out_retry_exhausted" || cause === "native_workspace_sync_out_unrecoverable";
|
||||
}
|
||||
|
||||
/**
|
||||
* The execution workspace a reconcile action should target. The recovery card is rendered from a
|
||||
* specific `workspace_validation` recovery action whose evidence pins the workspace that diverged;
|
||||
|
||||
@@ -2315,6 +2315,12 @@ export function DesignGuide() {
|
||||
recovery. Recovery decisions and attempts belong in the run log;
|
||||
there is no execution status card or reconciliation form.
|
||||
</p>
|
||||
<p className="text-sm text-muted-foreground">
|
||||
When retained-file recovery needs another authorized request, the source task and
|
||||
run inspector offer Recover saved files. This queues the existing file-preservation
|
||||
worker. Work remains held until the server verifies the saved files; a queued
|
||||
acknowledgement does not mean that recovery finished.
|
||||
</p>
|
||||
</Section>
|
||||
|
||||
<Section title="Cloud sign-in unavailable">
|
||||
|
||||
@@ -84,6 +84,9 @@ const mockIssuesApi = vi.hoisted(() => ({
|
||||
markRead: vi.fn(),
|
||||
update: vi.fn(),
|
||||
resolveRecoveryAction: vi.fn(),
|
||||
recoveryActions: vi.fn(),
|
||||
recoverWorkspace: vi.fn(),
|
||||
retryTask: vi.fn(),
|
||||
previewTreeControl: vi.fn(),
|
||||
getTreeControlState: vi.fn(),
|
||||
listTreeHolds: vi.fn(),
|
||||
@@ -1376,6 +1379,9 @@ describe("IssueDetail", () => {
|
||||
mockIssuesApi.listComments.mockResolvedValue([]);
|
||||
mockIssuesApi.listAttachments.mockResolvedValue([]);
|
||||
mockIssuesApi.listWorkProducts.mockResolvedValue([]);
|
||||
mockIssuesApi.recoveryActions.mockReset();
|
||||
mockIssuesApi.recoverWorkspace.mockReset();
|
||||
mockIssuesApi.retryTask.mockReset();
|
||||
mockIssuesApi.checkMonitorNow.mockReset();
|
||||
mockIssuesApi.listFeedbackVotes.mockResolvedValue([]);
|
||||
mockIssuesApi.listInteractions.mockResolvedValue([]);
|
||||
@@ -3423,6 +3429,89 @@ describe("IssueDetail", () => {
|
||||
mockIssuesApi.update.mockReset();
|
||||
});
|
||||
|
||||
it.each(["verified", "unverified", "stale", "denied"] as const)("keeps native export Retry closed with %s preservation access or source", async mode => {
|
||||
const action = {
|
||||
id: "file-recovery", companyId: "company-1", sourceIssueId: "issue-1",
|
||||
kind: "active_run_watchdog", cause: "native_workspace_sync_out_retry_exhausted",
|
||||
status: "active", ownerType: "system", evidence: { runId: "stopped-run", workspaceRecovery: {
|
||||
schema: "paperclip.workspace-recovery.v1", runId: "stopped-run", status: "blocked",
|
||||
stage: "restoring_files", requestIds: [], retryable: true,
|
||||
}, systemRecovery: { state: "exhausted", preservationOperationIds: [] } },
|
||||
} as unknown as NonNullable<Issue["activeRecoveryAction"]>;
|
||||
const issue = createIssue({ status: "blocked", assigneeAgentId: "agent-1", activeRecoveryAction: action,
|
||||
interruption: { intentId: "held-input", responsibility: "system", state: "failed", nextRetryAt: null,
|
||||
canRetry: true, userAction: null, sourceRunIds: ["stopped-run"], observedRunId: "stopped-run" },
|
||||
executionBlocker: { runId: "stopped-run", cause: "native_workspace_sync_out_retry_exhausted", canRetry: false, workspaceRepairRequired: true,
|
||||
workspaceRecovery: { status: "blocked", stage: "restoring_files", canRetry: true } } as Issue["executionBlocker"],
|
||||
});
|
||||
mockIssuesApi.get.mockResolvedValue(issue);
|
||||
mockAuthApi.getSession.mockResolvedValue({ user: { id: "file-operator" } });
|
||||
mockAccessApi.getCurrentBoardAccess.mockResolvedValue({ userId: "file-operator", source: "session",
|
||||
isInstanceAdmin: false, companyIds: ["company-1"],
|
||||
memberships: [{ companyId: "company-1", status: "active", membershipRole: mode === "denied" ? "viewer" : "operator" }],
|
||||
});
|
||||
mockIssuesApi.recoveryActions.mockResolvedValue({ active: action, actions: [action], sourceInspection: {
|
||||
actionId: mode === "stale" ? "other-action" : action.id, runId: "stopped-run",
|
||||
status: mode === "unverified" ? "blocked" : "verified", scope: "recorded_source_identity",
|
||||
} });
|
||||
mockIssuesApi.recoverWorkspace.mockResolvedValue({ actionId: action.id, status: "queued" });
|
||||
await act(async () => renderIssueView());
|
||||
if (mode !== "verified") {
|
||||
await waitForAssertion(() => expect(container.textContent).toContain(mode === "denied"
|
||||
? "A board member with task access" : "The recorded source is unavailable or has changed"));
|
||||
expect([...container.querySelectorAll("button")].some(button => ["Recover saved files", "Retry"].includes(button.textContent ?? ""))).toBe(false);
|
||||
expect(mockIssuesApi.recoverWorkspace).not.toHaveBeenCalled();
|
||||
expect(mockIssuesApi.retryTask).not.toHaveBeenCalled();
|
||||
return;
|
||||
}
|
||||
await waitForAssertion(() => expect([...container.querySelectorAll("button")]
|
||||
.some(button => button.textContent === "Recover saved files")).toBe(true));
|
||||
expect([...container.querySelectorAll("button")].some(button => button.textContent === "Retry")).toBe(false);
|
||||
const preserve = [...container.querySelectorAll("button")].find(button => button.textContent === "Recover saved files")!;
|
||||
await act(async () => preserve.click());
|
||||
await waitForAssertion(() => expect(mockIssuesApi.recoverWorkspace).toHaveBeenCalledExactlyOnceWith("issue-1", {
|
||||
actionId: action.id, runId: "stopped-run", idempotencyKey: expect.any(String),
|
||||
}));
|
||||
expect(mockIssuesApi.resolveRecoveryAction).not.toHaveBeenCalled();
|
||||
expect(mockIssuesApi.update).not.toHaveBeenCalled();
|
||||
expect(issue.executionBlocker?.workspaceRepairRequired).toBe(true);
|
||||
expect(container.textContent).not.toContain("Saved files recovered");
|
||||
});
|
||||
|
||||
it("keeps the existing Retry path for exhausted legacy workspace restoration", async () => {
|
||||
const interruption: NonNullable<Issue["interruption"]> = { intentId: "legacy-input", responsibility: "system", state: "failed", nextRetryAt: null,
|
||||
canRetry: true, userAction: null, sourceRunIds: ["legacy-run"], observedRunId: "legacy-run" };
|
||||
const issue = createIssue({ status: "blocked", assigneeAgentId: "agent-1", interruption,
|
||||
activeRecoveryAction: { id: "legacy-recovery", companyId: "company-1", sourceIssueId: "issue-1",
|
||||
kind: "active_run_watchdog", cause: "legacy_execution_requires_reconciliation", status: "active", ownerType: "system",
|
||||
evidence: { runId: "legacy-run", workspaceRestoreFailure: "restore_failed",
|
||||
workspaceRestoreRecovery: { schema: "paperclip.workspace-restore-recovery.v1", leaseIds: ["legacy-lease"] },
|
||||
systemRecovery: { state: "exhausted" } },
|
||||
} as unknown as NonNullable<Issue["activeRecoveryAction"]>,
|
||||
executionBlocker: { runId: "legacy-run", cause: "legacy_execution_requires_reconciliation",
|
||||
canRetry: true, workspaceRepairRequired: true } as Issue["executionBlocker"],
|
||||
});
|
||||
mockIssuesApi.get.mockResolvedValue(issue);
|
||||
mockAuthApi.getSession.mockResolvedValue({ user: { id: "legacy-operator" } });
|
||||
mockAccessApi.getCurrentBoardAccess.mockResolvedValue({ userId: "legacy-operator", source: "session",
|
||||
isInstanceAdmin: false, companyIds: ["company-1"],
|
||||
memberships: [{ companyId: "company-1", status: "active", membershipRole: "operator" }],
|
||||
});
|
||||
mockIssuesApi.retryTask.mockResolvedValue({ requestId: "legacy-retry", accepted: true, stale: false, presentation: interruption });
|
||||
await act(async () => renderIssueView());
|
||||
await waitForAssertion(() => expect([...container.querySelectorAll("button")].some(button => button.textContent === "Retry")).toBe(true));
|
||||
expect([...container.querySelectorAll("button")].some(button => button.textContent === "Recover saved files")).toBe(false);
|
||||
const retry = [...container.querySelectorAll("button")].find(button => button.textContent === "Retry")!;
|
||||
await act(async () => retry.click());
|
||||
await waitForAssertion(() => expect(mockIssuesApi.retryTask).toHaveBeenCalledExactlyOnceWith(issue.id, {
|
||||
idempotencyKey: expect.any(String), observedRunId: "legacy-run",
|
||||
}));
|
||||
expect(mockIssuesApi.recoverWorkspace).not.toHaveBeenCalled();
|
||||
expect(mockIssuesApi.resolveRecoveryAction).not.toHaveBeenCalled();
|
||||
expect(mockIssuesApi.update).not.toHaveBeenCalled();
|
||||
expect(issue.executionBlocker?.workspaceRepairRequired).toBe(true);
|
||||
});
|
||||
|
||||
it("moves a blocked task back to todo when the no-live-path notice tries again", async () => {
|
||||
const activeRecoveryAction = {
|
||||
id: "recovery-action-1",
|
||||
|
||||
@@ -85,9 +85,11 @@ import {
|
||||
type LiveRunForIssue,
|
||||
} from "../api/heartbeats";
|
||||
import { instanceSettingsApi } from "../api/instanceSettings";
|
||||
import { accessApi, type CurrentBoardAccess } from "../api/access";
|
||||
import { accessApi } from "../api/access";
|
||||
import {
|
||||
canBoardManageRuntime,
|
||||
canBoardResolveRecoveryAction,
|
||||
isRetainedWorkspaceExportCause,
|
||||
readRecoveryReconcileWorkspaceId,
|
||||
} from "../lib/recovery-reconcile";
|
||||
import { agentsApi } from "../api/agents";
|
||||
@@ -489,31 +491,11 @@ function treeControlPreviewErrorCopy(error: unknown): string {
|
||||
return error instanceof Error ? error.message : "Unable to load preview.";
|
||||
}
|
||||
|
||||
export function canBoardResolveRecoveryAction(
|
||||
companyId: string | null | undefined,
|
||||
boardAccess: CurrentBoardAccess | undefined,
|
||||
) {
|
||||
if (!companyId || !boardAccess) return false;
|
||||
if (boardAccess.source === "local_implicit" || boardAccess.isInstanceAdmin)
|
||||
return true;
|
||||
if (!boardAccess.memberships || boardAccess.memberships.length === 0) {
|
||||
return boardAccess.companyIds.includes(companyId);
|
||||
}
|
||||
|
||||
const membership = boardAccess.memberships.find(
|
||||
(item) => item.companyId === companyId && item.status === "active",
|
||||
);
|
||||
if (!membership) return false;
|
||||
return (
|
||||
membership.membershipRole !== "viewer" && membership.membershipRole !== null
|
||||
);
|
||||
}
|
||||
|
||||
// `canBoardManageRuntime` and `readRecoveryReconcileWorkspaceId` moved to `@/lib/recovery-reconcile`
|
||||
// so the run-page recovery surface can reuse them without importing this page module. Re-exported
|
||||
// here (from the top-of-file import) to keep existing import sites — and their tests — stable, while
|
||||
// the imported bindings stay usable within this module.
|
||||
export { canBoardManageRuntime, readRecoveryReconcileWorkspaceId };
|
||||
export { canBoardManageRuntime, canBoardResolveRecoveryAction, readRecoveryReconcileWorkspaceId };
|
||||
|
||||
export function shouldScrollIssueDetailToTopOnNavigation(input: {
|
||||
previousIssueId: string | undefined;
|
||||
@@ -8144,15 +8126,18 @@ export function TaskDetailSurface({ conversation, tasksTab }: { tasksTab?: TaskS
|
||||
issueCacheRefs={issueCacheRefs}
|
||||
/>
|
||||
|
||||
{resolvedDetailTab === "chat" && !issue.interruption && !issue.executionBlocker?.workspaceRecovery && (
|
||||
{resolvedDetailTab === "chat" && (
|
||||
<WorkspaceExportRecovery key={`workspace-export:${issue.activeRecoveryAction?.id ?? issue.id}`}
|
||||
className={shellSectionClass}
|
||||
issueId={issue.id} companyId={issue.companyId}
|
||||
showStatus={!issue.interruption && !issue.executionBlocker?.workspaceRecovery}
|
||||
action={issue.activeRecoveryAction ?? null} />
|
||||
)}
|
||||
{resolvedDetailTab === "chat" && (
|
||||
<ExecutionBlockerNotice className={shellSectionClass} presentation={issue.interruption}
|
||||
issueId={issue.id} agentName={agentMap.get(issue.assigneeAgentId ?? "")?.name} projectName={issue.project?.name}
|
||||
canRetry={canResolveBoardRecoveryAction} onRetry={taskRetry.retry}
|
||||
canRetry={canResolveBoardRecoveryAction && !(issue.executionBlocker?.workspaceRepairRequired
|
||||
&& isRetainedWorkspaceExportCause(issue.executionBlocker.cause))} onRetry={taskRetry.retry}
|
||||
optimistic={taskRetry.optimistic} takingLonger={taskRetry.takingLonger} error={taskRetry.error} />
|
||||
)}
|
||||
|
||||
|
||||
Reference in new issue
Block a user