The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
Fix import completion UX: inbox flood, false-failure message, stale company list (#10538)
Devin Foley075951f6bde5
diff --git a/server/src/__tests__/company-portability-import-batching.test.ts b/server/src/__tests__/company-portability-import-batching.test.tsindex 7cc08ccbd1..4c32bfe5cd 100644--- a/server/src/__tests__/company-portability-import-batching.test.ts+++ b/server/src/__tests__/company-portability-import-batching.test.ts@@ -7,17 +7,19 @@ import {issueAttachments,issueComments,issueDocuments,+ issueInboxArchives,issueLabels,issueRelations,issueWorkProducts,issues,} from "@paperclipai/db";-import { eq, sql } from "drizzle-orm";+import { and, eq, sql } from "drizzle-orm";import {getEmbeddedPostgresTestSupport,startEmbeddedPostgresTestDatabase,} from "./helpers/embedded-postgres.js";import { companyPortabilityService } from "../services/company-portability.js";+import { issueService } from "../services/issues.js";import { workProductService } from "../services/work-products.js";import type { ImportIssueWorkProductRow } from "../services/import-write-types.js";import type { CompanyPortabilityFileEntry } from "@paperclipai/shared";@@ -194,6 +196,35 @@ function buildSyntheticBundle(options: SyntheticBundleOptions): {return { rootPath: "batching-bench", files };}+/**+ * Build a bundle whose every task carries a *user*-authored comment. On import,+ * user comments are re-attributed to the importing user, so every issue becomes+ * "touched by me" — the exact shape that used to flood the inbox after an+ * import. The inbox seeding is what must keep them hidden.+ */+function buildTouchedIssuesBundle(issueCount: number): {+ rootPath: string;+ files: Record<string, CompanyPortabilityFileEntry>;+} {+ const files: Record<string, CompanyPortabilityFileEntry> = {};+ files["COMPANY.md"] = ['---', 'schema: "agentcompanies/v1"', 'name: "Inbox Flood Co"', '---', '', 'Synthetic import bundle.', ''].join("\n");++ const tasks: Record<string, unknown> = {};+ for (let i = 1; i <= issueCount; i += 1) {+ const slug = `task-${String(i).padStart(4, "0")}`;+ files[`tasks/${slug}/TASK.md`] = ['---', `name: "Task ${i}"`, "kind: task", '---', '', `Body for task ${i}.`, ''].join("\n");+ tasks[slug] = {+ status: "todo",+ priority: "medium",+ comments: [{ body: `A human note on task ${i}.`, authorType: "user" }],+ documents: [],+ };+ }++ files[".paperclip.yaml"] = renderPaperclipYaml({ schemaVersion: 6, tasks });+ return { rootPath: "inbox-flood", files };+}+describeEmbeddedPostgres("company import batches inserts", () => {let tempDb: Awaited<ReturnType<typeof startEmbeddedPostgresTestDatabase>> | null = null;let db!: ReturnType<typeof createDb>;@@ -270,6 +301,76 @@ describeEmbeddedPostgres("company import batches inserts", () => {expect(uniqueIdentifiers.size).toBe(issueCount);});+ it("keeps imported issues out of the importing user's inbox", async () => {+ const importingUserId = "board-inbox-user";+ const bundle = buildTouchedIssuesBundle(3);+ const portability = companyPortabilityService(db);++ const result = await portability.importBundle(+ {+ source: { type: "inline", rootPath: bundle.rootPath, files: bundle.files },+ include: { company: true, agents: false, projects: false, issues: true },+ target: { mode: "new_company", newCompanyName: "Inbox Flood Co" },+ collisionStrategy: "rename",+ },+ importingUserId,+ );+ const companyId = result.company.id;++ const importedIssues = await db+ .select({ id: issues.id })+ .from(issues)+ .where(eq(issues.companyId, companyId));+ expect(importedIssues.length).toBe(3);+ const importedIds = new Set(importedIssues.map((row) => row.id));++ // Every imported issue is seeded with a per-user inbox archive, attributed+ // to the importing board user (not an agent).+ const archives = await db+ .select({+ issueId: issueInboxArchives.issueId,+ archivedByActorType: issueInboxArchives.archivedByActorType,+ })+ .from(issueInboxArchives)+ .where(and(+ eq(issueInboxArchives.companyId, companyId),+ eq(issueInboxArchives.userId, importingUserId),+ ));+ expect(new Set(archives.map((row) => row.issueId))).toEqual(importedIds);+ expect(archives.every((row) => row.archivedByActorType === "user")).toBe(true);++ const issuesSvc = issueService(db);++ // Sanity: the imported issues really are "touched by me" (their user comment+ // was re-attributed to the importing user), so without the archive filter+ // they would all flood the inbox.+ const touched = await issuesSvc.list(companyId, { touchedByUserId: importingUserId });+ expect(new Set(touched.map((issue) => issue.id))).toEqual(importedIds);++ // The inbox "mine" query (touched AND not inbox-archived) returns none of+ // them — the seeding is load-bearing.+ const mineInbox = await issuesSvc.list(companyId, {+ touchedByUserId: importingUserId,+ inboxArchivedByUserId: importingUserId,+ });+ expect(mineInbox.filter((issue) => importedIds.has(issue.id))).toEqual([]);++ // Normal (non-import) creation is unaffected: an issue the same user creates+ // after the import is not archived and shows up in their inbox.+ const fresh = await issuesSvc.create(companyId, {+ title: "Freshly created work",+ status: "todo",+ priority: "medium",+ createdByUserId: importingUserId,+ });+ const mineAfterCreate = await issuesSvc.list(companyId, {+ touchedByUserId: importingUserId,+ inboxArchivedByUserId: importingUserId,+ });+ expect(mineAfterCreate.map((issue) => issue.id)).toContain(fresh.id);+ expect(mineAfterCreate.filter((issue) => importedIds.has(issue.id))).toEqual([]);+ });+it("rolls back the whole work-product batch when a later chunk fails", async () => {// Seed a real company + issue to hang work products off of.const bundle = buildSyntheticBundle({ issueCount: 1, commentsPerIssue: 0, documentsPerIssue: 0 });diff --git a/server/src/__tests__/company-portability-routes.test.ts b/server/src/__tests__/company-portability-routes.test.tsindex 2de71aba9d..9a06ba9f5a 100644--- a/server/src/__tests__/company-portability-routes.test.ts+++ b/server/src/__tests__/company-portability-routes.test.ts@@ -790,7 +790,23 @@ describe.sequential("company portability routes", () => {}),}));- const nowSpy = vi.spyOn(Date, "now").mockReturnValue(Date.parse(succeeded.body.job.completedAt) + (5 * 60 * 1000) + 1);+ const completedAtMs = Date.parse(succeeded.body.job.completedAt);++ // A completed job stays resolvable well past the old 5-minute retention so a+ // user who steps away during a long import never polls into a false 404.+ const withinWindow = vi.spyOn(Date, "now").mockReturnValue(completedAtMs + (5 * 60 * 1000) + 1);+ try {+ const stillThere = await request(app).get(accepted.body.statusUrl).set(cloudHeaders);+ expect(stillThere.status).toBe(200);+ expect(stillThere.body.job.status).toBe("succeeded");+ expect(stillThere.body.job.result.companyId).toBe(companyId);+ } finally {+ withinWindow.mockRestore();+ }++ // Only past the extended 60-minute window is the in-memory record finally+ // dropped, and only then does the status route report the job as gone.+ const nowSpy = vi.spyOn(Date, "now").mockReturnValue(completedAtMs + (60 * 60 * 1000) + 1);try {const expired = await request(app).get(accepted.body.statusUrl).set(cloudHeaders);expect(expired.status).toBe(404);diff --git a/server/src/__tests__/company-portability.test.ts b/server/src/__tests__/company-portability.test.tsindex 6f93494ec8..47214b5829 100644--- a/server/src/__tests__/company-portability.test.ts+++ b/server/src/__tests__/company-portability.test.ts@@ -48,6 +48,7 @@ const issueSvc = {listAttachments: vi.fn(),createAttachment: vi.fn(),importIssues: vi.fn(),+ archiveImportedInbox: vi.fn(),addImportedComments: vi.fn(),addImportedAttachments: vi.fn(),};diff --git a/server/src/routes/companies.ts b/server/src/routes/companies.tsindex 8a9b38df8d..516ac95d29 100644--- a/server/src/routes/companies.ts+++ b/server/src/routes/companies.ts@@ -191,7 +191,14 @@ export function companyRoutes(db: Db, storage?: StorageService) {const artifacts = companyArtifactsService(db, storage);const feedback = feedbackService(db);const importJobs = new Map<string, ImportJobRecord>();- const importJobTerminalRetentionMs = 5 * 60 * 1000;+ // Terminal jobs are retained in memory for an hour after they settle. A long+ // import can outlast a user stepping away, and dropping the completion after+ // only a few minutes made a later poll 404 — surfacing a finished, fully+ // written import as a scary failure. An hour is long enough to cover a real+ // "walk away and come back" gap while keeping the map bounded, and it needs+ // no new persistence (jobs remain in-memory-only; a restart still 404s, which+ // the client now treats as a soft success once it has seen the job running).+ const importJobTerminalRetentionMs = 60 * 60 * 1000;function parseBooleanQuery(value: unknown) {return value === true || value === "true" || value === "1";diff --git a/server/src/services/company-portability.ts b/server/src/services/company-portability.tsindex c49c8d2bf4..eb7a448132 100644--- a/server/src/services/company-portability.ts+++ b/server/src/services/company-portability.ts@@ -6041,6 +6041,19 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {// handful per table. Empty buffers are skipped so an issues-free import// (e.g. routines only) issues no writes at all.if (issueRows.length > 0) await issues.importIssues(targetCompany.id, issueRows);+ // Imported issues are historical work, not new inbox items. Seed a+ // per-user inbox archive for the importing board user so a large import+ // (a real 1,418-task company shipped every task to the inbox) does not+ // flood it: the inbox "mine" query hides archived issues, and genuine+ // new activity still resurfaces them. Agent/system imports (no board+ // user) have no inbox to protect, so the seeding is skipped.+ if (actorUserId && issueRows.length > 0) {+ await issues.archiveImportedInbox(+ targetCompany.id,+ issueRows.map((row) => row.id),+ actorUserId,+ );+ }if (commentRows.length > 0) await issues.addImportedComments(commentRows);if (documentRows.length > 0) await documentsSvc.createIssueDocumentsForImport(documentRows);if (workProductRows.length > 0) await workProductsSvc.createManyForImport(workProductRows);diff --git a/server/src/services/issues.ts b/server/src/services/issues.tsindex f30bc272f0..721d15deee 100644--- a/server/src/services/issues.ts+++ b/server/src/services/issues.ts@@ -5220,6 +5220,40 @@ export function issueService(db: Db) {return row;},+ /**+ * Seed inbox archives for a batch of freshly imported issues so a company+ * import does not flood the importing user's inbox. Imported issues are+ * historical work, not new inbox items, but the inbox "mine" query surfaces+ * every touched-and-not-archived issue; a 1000-task import would otherwise+ * bury the inbox. Seeding a per-user inbox archive keeps them hidden via+ * `inboxVisibleForUserCondition`, while genuine new activity on an imported+ * issue still resurfaces it. This runs only on import (mirroring how+ * `pauseAutomations` threads an import-only suppression) and never touches+ * normal issue creation. Rows carry the same "user"-attributed shape a+ * manual inbox archive writes, batched to stay under Postgres bind limits.+ */+ archiveImportedInbox: async (+ companyId: string,+ issueIds: string[],+ userId: string,+ archivedAt: Date = new Date(),+ ): Promise<void> => {+ if (issueIds.length === 0) return;+ const now = new Date();+ const rows = issueIds.map((issueId) => ({+ companyId,+ issueId,+ userId,+ archivedByActorType: "user" as const,+ archivedByAgentId: null,+ archivedByRunId: null,+ archivedAt,+ createdAt: now,+ updatedAt: now,+ }));+ await insertRowsInChunks(db, issueInboxArchives, rows);+ },+unarchiveInbox: async (companyId: string, issueId: string, userId: string) => {const [row] = await db.delete(issueInboxArchives)diff --git a/ui/src/api/companies.ts b/ui/src/api/companies.tsindex 04c7d09daa..45f5e77b27 100644--- a/ui/src/api/companies.ts+++ b/ui/src/api/companies.ts@@ -46,6 +46,17 @@ export interface CompanyImportJobStatus {updatedAt?: string;completedAt?: string;error?: { message: string };+ /**+ * Summary retained for every terminal job (board and cloud tenant); carries+ * the imported company id so the page can navigate even when the full+ * `importResult` is no longer available.+ */+ result?: {+ companyId: string;+ agentCount?: number;+ warningCount?: number;+ companyAction?: unknown;+ };/** Board-created jobs carry the full result for parity with the sync response. */importResult?: CompanyPortabilityImportResult;};diff --git a/ui/src/pages/CompanyImport.test.tsx b/ui/src/pages/CompanyImport.test.tsxindex 07ff1abf4c..ac531c8ab5 100644--- a/ui/src/pages/CompanyImport.test.tsx+++ b/ui/src/pages/CompanyImport.test.tsx@@ -659,6 +659,87 @@ describe("CompanyImport", () => {expect(container.textContent).toContain("Import complete");});+ it("treats a server-confirmed success without a full result as a soft success and refreshes the company list", async () => {+ // The server reports the job `succeeded` but retains only the compact+ // summary (a cloud tenant job, or a board job whose full in-memory result+ // aged out): status is a confirmed success, `importResult` is gone, and the+ // summary still carries the company id. That is a success we can no longer+ // fully read — never a scary failure.+ mockCompaniesApi.getImportJob.mockResolvedValue({+ job: { id: "job-1", status: "succeeded", result: { companyId: "company-2" } },+ });++ const invalidateSpy = vi.spyOn(QueryClient.prototype, "invalidateQueries");+ try {+ await renderPageAndImport();++ // Success-leaning panel, not the failure panel.+ expect(container.textContent).toContain("Import completed");+ expect(container.textContent).toContain("open it to view it");+ expect(container.textContent).not.toContain("Import failed");+ expect(mockPushToast).toHaveBeenCalledWith(expect.objectContaining({ tone: "success" }));+ // The company list is refreshed so the new company appears in the switcher.+ expect(invalidateSpy).toHaveBeenCalledWith(expect.objectContaining({ queryKey: ["companies"] }));+ // The summary's company id still drives navigation into the import.+ expect(mockSetSelectedCompanyId).toHaveBeenCalledWith("company-2");+ } finally {+ invalidateSpy.mockRestore();+ }+ });++ it("surfaces a first-poll 404 as an error because the job never existed", async () => {+ // A 404 on the very first poll — before the client ever saw the job+ // running — means the id never existed. That stays a hard error.+ mockCompaniesApi.getImportJob.mockRejectedValue(+ new ApiError("Import job not found", 404, { error: "Import job not found" }),+ );++ await renderPage();+ await enterGithubUrl();+ await clickButton((text) => text === "Preview import");+ await clickButton((text) => text.startsWith("Import 3 file"));+ await settle();++ expect(container.textContent).toContain("Import failed:");+ expect(container.textContent).toContain("it may have restarted while the import ran");+ expect(container.textContent).not.toContain("Import completed");+ expect(mockPushToast).toHaveBeenCalledWith(expect.objectContaining({ tone: "error" }));+ });++ it("surfaces a running-then-gone job as an error because the server restarted mid-import", async () => {+ // The first poll finds the job running; the next poll 404s. A running job is+ // never dropped by the retention sweep (only settled jobs age out), so its+ // disappearance means the server restarted mid-import — the import never+ // reached a confirmed success and may not have finished. Report that+ // honestly instead of masking a possibly-incomplete import as completed.+ mockCompaniesApi.getImportJob+ .mockResolvedValueOnce({ job: { id: "job-1", status: "running" } })+ .mockRejectedValue(new ApiError("Import job not found", 404, { error: "Import job not found" }));++ await renderPage();+ await enterGithubUrl();+ await clickButton((text) => text === "Preview import");+ await clickButton((text) => text.startsWith("Import 3 file"));+ await settle();++ expect(container.textContent).toContain("Import failed:");+ expect(container.textContent).toContain("it may have restarted while the import ran");+ expect(container.textContent).not.toContain("Import completed");+ expect(mockPushToast).toHaveBeenCalledWith(expect.objectContaining({ tone: "error" }));+ });++ it("refreshes the company list on a full import success", async () => {+ const invalidateSpy = vi.spyOn(QueryClient.prototype, "invalidateQueries");+ try {+ await renderPageAndImport();++ expect(container.textContent).toContain("Import complete");+ expect(invalidateSpy).toHaveBeenCalledWith(expect.objectContaining({ queryKey: ["companies"] }));+ } finally {+ invalidateSpy.mockRestore();+ }+ });+it("resumes watching a stored import job on mount", async () => {// A previous page load persisted a running job; reloading must resume// watching it rather than showing the stale form.diff --git a/ui/src/pages/CompanyImport.tsx b/ui/src/pages/CompanyImport.tsxindex d2921f6d99..5aecd4a437 100644--- a/ui/src/pages/CompanyImport.tsx+++ b/ui/src/pages/CompanyImport.tsx@@ -709,17 +709,39 @@ function runningImportJobFromError(err: unknown): CompanyImportJobAccepted | nul};}-/** Poll a job to a terminal state; resolves with the import result or throws the job's error. */+/**+ * Terminal outcome of watching an import job.+ *+ * - `completed` carries the full import result and drives the activation path.+ * - `completed-expired` is a *server-confirmed* success whose full result we+ * can no longer read: the server reported the job `succeeded` but retained+ * only its compact summary — a cloud tenant job, or a board job whose full+ * in-memory result aged out. The company id lets the page still navigate to+ * the imported company. This is never a failure: the server confirmed the+ * import succeeded before we stopped being able to read the full result.+ */+type CompanyImportWatchOutcome =+ | { status: "completed"; result: CompanyPortabilityImportResult }+ | { status: "completed-expired"; companyId: string | null };++/** Poll a job to a terminal state; resolves with the outcome or throws the job's error. */async function watchImportJob(jobId: string,storageKey: string,-): Promise<CompanyPortabilityImportResult> {+): Promise<CompanyImportWatchOutcome> {for (;;) {let job: Awaited<ReturnType<typeof companiesApi.getImportJob>>["job"] | null = null;try {job = (await companiesApi.getImportJob(jobId)).job;} catch (err) {if (err instanceof ApiError && err.status === 404) {+ // The server has no record of this job. The retention sweep only drops+ // jobs that have already *settled* (a running job is never removed), so+ // a 404 while we are still watching means the in-memory record was lost+ // to a restart mid-import — the import never reached a confirmed+ // `succeeded` state and may not have finished. Report that honestly+ // rather than masking a possibly-incomplete import as a success; the+ // refreshed company list lets the user confirm what actually landed.clearStoredImportJob(storageKey);throw new Error("The server no longer reports this import job — it may have restarted while the import ran.",@@ -748,9 +770,15 @@ async function watchImportJob(if (job?.status === "succeeded") {clearStoredImportJob(storageKey);if (!job.importResult) {- throw new Error("The import finished, but its result is no longer available.");+ // The server confirmed success but retained only the compact summary+ // (a cloud tenant job, or a board job whose full result aged out of+ // memory). Still a success — navigate by the summary's company id.+ return {+ status: "completed-expired",+ companyId: job.result?.companyId ?? null,+ };}- return job.importResult;+ return { status: "completed", result: job.importResult };}if (job?.status === "failed") {clearStoredImportJob(storageKey);@@ -813,11 +841,16 @@ export function CompanyImport() {// Post-import success / activation stateconst [pauseAutomations, setPauseAutomations] = useState(true);- const [importOutcome, setImportOutcome] = useState<{- result: CompanyPortabilityImportResult;- dashboardPath: string;- pausedAutomations: boolean;- } | null>(null);+ const [importOutcome, setImportOutcome] = useState<+ | {+ kind: "full";+ result: CompanyPortabilityImportResult;+ dashboardPath: string;+ pausedAutomations: boolean;+ }+ | { kind: "expired" }+ | null+ >(null);const [activationChecked, setActivationChecked] = useState<Set<string>>(new Set());const [activatedKeys, setActivatedKeys] = useState<Set<string>>(new Set());const [activationFailures, setActivationFailures] = useState<Record<string, string>>({});@@ -1042,9 +1075,36 @@ export function CompanyImport() {});return watchImportJob(accepted.job.id, storageKey);},- onSuccess: async (result, { previewForImport, pauseAutomations: submittedPauseAutomations }) => {+ onSuccess: async (outcome, { previewForImport, pauseAutomations: submittedPauseAutomations }) => {setResumedWatchJobId(null);+ // The company list powers the switcher; refresh it on every success path+ // so the imported company appears immediately without a manual reload.await queryClient.invalidateQueries({ queryKey: queryKeys.companies.all });++ if (outcome.status === "completed-expired") {+ // The import finished and wrote all its data, but the job's result+ // expired (or was never retained) before we could read it. This is a+ // success, not a failure: surface it gently and let the refreshed+ // switcher carry the user into the new company.+ if (outcome.companyId) {+ try {+ const importedCompany = await companiesApi.get(outcome.companyId);+ setSelectedCompanyId(importedCompany.id);+ } catch {+ // The company id may be unreadable (permissions, race); the+ // refreshed company list still surfaces the import.+ }+ }+ setImportOutcome({ kind: "expired" });+ pushToast({+ tone: "success",+ title: "Import completed",+ body: "Open the company to view it.",+ });+ return;+ }++ const result = outcome.result;const importedCompany = await companiesApi.get(result.company.id);const refreshedSession = currentUserId? null@@ -1063,6 +1123,7 @@ export function CompanyImport() {setActivatedKeys(new Set());setActivationFailures({});setImportOutcome({+ kind: "full",result,dashboardPath: `/${importedCompany.issuePrefix}/dashboard`,pausedAutomations: submittedPauseAutomations,@@ -1301,7 +1362,7 @@ export function CompanyImport() {}async function handleActivateSelected() {- if (!importOutcome || isActivating) return;+ if (!importOutcome || importOutcome.kind !== "full" || isActivating) return;setIsActivating(true);const nextActivated = new Set(activatedKeys);const nextFailures: Record<string, string> = {};@@ -1374,6 +1435,24 @@ export function CompanyImport() {: null;const selectedAction = selectedFile ? (actionMap.get(selectedFile) ?? null) : null;+ if (importOutcome && importOutcome.kind === "expired") {+ // Soft success: the import finished and wrote all its data, but the job's+ // in-memory result expired before we could read it. Never a failure — the+ // company list has been refreshed, so the imported company is available+ // from the switcher.+ return (+ <div className="px-5 py-5 space-y-4">+ <div>+ <h2 className="text-base font-semibold">Import completed</h2>+ <p className="text-xs text-muted-foreground mt-1">+ The import finished and your company is ready. Its detailed summary is no+ longer available, but the company has been added — open it to view it.+ </p>+ </div>+ </div>+ );+ }+if (importOutcome) {const { result, dashboardPath } = importOutcome;const activationItems = importOutcome.pausedAutomations ? buildActivationItems(result) : [];