@devries-cameron20 / t3code Mirror · read-only / commits / 54346a617c
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 22, 22:00 UTC

fix(web,server): adding a project to another machine takes you there, with no toasts and the right favicon (#22254)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Theo Browne committed Oct 20, 2026 at 02:50 UTC 54346a617c60ded22c1d37b4c14b2bb6ae83d7df
15 files changed +210 -54
apps/server/src/assets/AssetAccess.test.ts
+1
@@ -1525,6 +1525,7 @@ describe("AssetAccess", () => {
1525 cause: platformCause,
1526 });
1527 const resolver = ProjectFaviconResolver.ProjectFaviconResolver.of({
1528 + invalidate: () => Effect.void,
1529 resolvePath: () => Effect.fail(resolutionCause),
1530 });
1531
apps/server/src/assets/AssetAccess.ts
+18 -14
@@ -493,7 +493,8 @@ export const issueAssetUrl = Effect.fn("AssetAccess.issueAssetUrl")(function* (i
493 readonly resource: AssetResource;
494 readonly workspaceRoot?: string;
495 readonly projectFaviconPath?: string;
496 - readonly projectCheckoutPending?: boolean;
496 + /** Where a cloned project's checkout stands, while the clone tracker still knows it. */
497 + readonly projectCheckout?: "pending" | "cloned";
498 }) {
499 const fileSystem = yield* FileSystem.FileSystem;
500 const path = yield* Path.Path;
@@ -648,19 +649,22 @@ export const issueAssetUrl = Effect.fn("AssetAccess.issueAssetUrl")(function* (i
649 );
650 const faviconResolver = yield* ProjectFaviconResolver.ProjectFaviconResolver;
651 // A lookup in a half-cloned checkout would cache a miss that outlives the clone.
651 - const faviconPath = input.projectCheckoutPending
652 - ? null
653 - : yield* faviconResolver
654 - .resolvePath(workspaceRoot, input.projectFaviconPath ?? undefined)
655 - .pipe(
656 - Effect.mapError(
657 - (cause) =>
658 - new AssetProjectFaviconResolutionError({
659 - resource: input.resource,
660 - cause,
661 - }),
662 - ),
663 - );
652 + // Once it lands, a miss cached before (by enrichment) is stale too.
653 + if (input.projectCheckout === "cloned") yield* faviconResolver.invalidate(workspaceRoot);
654 + const faviconPath =
655 + input.projectCheckout === "pending"
656 + ? null
657 + : yield* faviconResolver
658 + .resolvePath(workspaceRoot, input.projectFaviconPath ?? undefined)
659 + .pipe(
660 + Effect.mapError(
661 + (cause) =>
662 + new AssetProjectFaviconResolutionError({
663 + resource: input.resource,
664 + cause,
665 + }),
666 + ),
667 + );
668 const isExternalOverride =
669 faviconPath !== null &&
670 input.projectFaviconPath !== undefined &&
apps/server/src/project/ManagedProjectFolders.test.ts
+1
@@ -47,6 +47,7 @@ const layerEnrichment = ProjectEnrichmentService.layer.pipe(
47 resolve: () => Effect.succeed(null),
48 }),
49 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
50 + invalidate: () => Effect.void,
51 resolvePath: () => Effect.succeed(null),
52 }),
53 ),
apps/server/src/project/ProjectEnrichmentService.test.ts
+9
@@ -58,6 +58,7 @@ it.effect("preserves either enrichment field when the other resolver fails", ()
58 : Effect.succeed(identity(workspaceRoot)),
59 }),
60 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
61 + invalidate: () => Effect.void,
62 resolvePath: (workspaceRoot) =>
63 workspaceRoot === "/favicon-fails"
64 ? Effect.fail(
@@ -109,6 +110,7 @@ it.effect("does not warn about favicons for workspace roots that no longer exist
110 resolve: (workspaceRoot) => Effect.succeed(identity(workspaceRoot)),
111 }),
112 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
113 + invalidate: () => Effect.void,
114 resolvePath: (workspaceRoot) =>
115 Effect.fail(
116 workspaceRoot === "/missing"
@@ -158,6 +160,7 @@ it.effect("publishes repository completion while favicon enrichment is still pen
160 resolve: (workspaceRoot) => Effect.succeed(identity(workspaceRoot)),
161 }),
162 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
163 + invalidate: () => Effect.void,
164 resolvePath: (workspaceRoot) =>
165 Deferred.await(releaseFavicon).pipe(Effect.as(`${workspaceRoot}/favicon.svg`)),
166 }),
@@ -186,6 +189,7 @@ it.effect("keeps repository workers available when every favicon worker is hung"
189 resolve: (workspaceRoot) => Effect.succeed(identity(workspaceRoot)),
190 }),
191 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
192 + invalidate: () => Effect.void,
193 resolvePath: () =>
194 Effect.gen(function* () {
195 const started = yield* Ref.updateAndGet(faviconStarts, (count) => count + 1);
@@ -237,6 +241,7 @@ it.effect("getAvailable returns immediately while repository identity is still u
241 ),
242 }),
243 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
244 + invalidate: () => Effect.void,
245 resolvePath: (workspaceRoot) => Effect.succeed(`${workspaceRoot}/favicon.svg`),
246 }),
247 );
@@ -285,6 +290,7 @@ it.effect(
290 },
291 }),
292 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
293 + invalidate: () => Effect.void,
294 resolvePath: () => Effect.succeed(null),
295 }),
296 );
@@ -344,6 +350,7 @@ it.effect("deduplicates requests, bounds pending work, and reloads invalidated r
350 }),
351 }),
352 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
353 + invalidate: () => Effect.void,
354 resolvePath: (workspaceRoot) => Effect.succeed(`${workspaceRoot}/favicon.svg`),
355 }),
356 );
@@ -403,6 +410,7 @@ it.effect("rescans a favicon only after 15 minutes", () =>
410 resolve: (workspaceRoot) => Effect.succeed(identity(workspaceRoot)),
411 }),
412 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
413 + invalidate: () => Effect.void,
414 resolvePath: (workspaceRoot) =>
415 Ref.updateAndGet(faviconScans, (count) => count + 1).pipe(
416 Effect.map((scan) => `${workspaceRoot}/favicon-${scan}.svg`),
@@ -451,6 +459,7 @@ it.effect(
459 ),
460 }),
461 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
462 + invalidate: () => Effect.void,
463 resolvePath: () => Ref.update(faviconScans, (count) => count + 1).pipe(Effect.as(null)),
464 }),
465 );
apps/server/src/project/ProjectEnrichmentService.ts
+2
@@ -283,6 +283,8 @@ export const make = Effect.fn("ProjectEnrichmentService.make")(function* (
283 [
284 Cache.invalidate(repositoryIdentityCache, workspaceRoot),
285 Cache.invalidate(faviconCache, workspaceRoot),
286 + // The resolver keeps its own misses, which would outlive a clone filling the folder.
287 + faviconResolver.invalidate(workspaceRoot),
288 ],
289 { concurrency: "unbounded", discard: true },
290 ),
apps/server/src/project/ProjectFaviconResolver.test.ts
+16
@@ -74,6 +74,22 @@ it.layer(layerTest)("ProjectFaviconResolverLive", (it) => {
74 }).pipe(Effect.provide(TestClock.layer())),
75 );
76
77 + it.effect("finds a favicon added after a cached miss once the workspace is invalidated", () =>
78 + Effect.gen(function* () {
79 + const resolver = yield* ProjectFaviconResolver.ProjectFaviconResolver;
80 + const path = yield* Path.Path;
81 + const cwd = yield* makeTempDir;
82 +
83 + // A clone's project exists while its folder is still empty.
84 + expect(yield* resolver.resolvePath(cwd)).toBeNull();
85 + yield* writeTextFile(cwd, "favicon.ico", "icon");
86 + expect(yield* resolver.resolvePath(cwd)).toBeNull();
87 +
88 + yield* resolver.invalidate(cwd);
89 + expect(yield* resolver.resolvePath(cwd)).toBe(path.join(cwd, "favicon.ico"));
90 + }),
91 + );
92 +
93 it.effect("falls back at once when a cached favicon is deleted", () =>
94 Effect.gen(function* () {
95 const fileSystem = yield* FileSystem.FileSystem;
apps/server/src/project/ProjectFaviconResolver.ts
+14 -1
@@ -111,6 +111,8 @@ export class ProjectFaviconResolver extends Context.Service<
111 cwd: string,
112 faviconPath?: string,
113 ) => Effect.Effect<string | null, ProjectFaviconResolutionError>;
114 + /** Forgets cached lookups for a workspace whose files changed, such as a finished clone. */
115 + readonly invalidate: (cwd: string) => Effect.Effect<void>;
116 }
117 >()("t3/project/ProjectFaviconResolver") {}
118
@@ -340,7 +342,18 @@ export const make = Effect.gen(function* () {
342 return yield* Cache.get(faviconCache, key);
343 });
344
343 - return ProjectFaviconResolver.of({ resolvePath });
345 + const invalidate: ProjectFaviconResolver["Service"]["invalidate"] = (cwd) =>
346 + Cache.keys(faviconCache).pipe(
347 + Effect.flatMap((keys) =>
348 + Effect.forEach(
349 + Array.from(keys).filter((key) => parseFaviconCacheKey(key).cwd === cwd),
350 + (key) => Cache.invalidate(faviconCache, key),
351 + { discard: true },
352 + ),
353 + ),
354 + );
355 +
356 + return ProjectFaviconResolver.of({ resolvePath, invalidate });
357 });
358
359 export const layer = Layer.effect(ProjectFaviconResolver, make);
apps/server/src/project/ProjectService.deletion.test.ts
+1
@@ -58,6 +58,7 @@ const layerServices = Layer.mergeAll(
58 resolve: () => Effect.succeed(null),
59 }),
60 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
61 + invalidate: () => Effect.void,
62 resolvePath: () => Effect.succeed(null),
63 }),
64 ),
apps/server/src/project/ProjectService.test.ts
+4
@@ -46,6 +46,7 @@ const layerMetadata = Layer.merge(
46 }),
47 }),
48 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
49 + invalidate: () => Effect.void,
50 resolvePath: (workspaceRoot) => Effect.succeed(`${workspaceRoot}/favicon.svg`),
51 }),
52 );
@@ -513,6 +514,7 @@ it.effect(
514 }),
515 }),
516 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
517 + invalidate: () => Effect.void,
518 resolvePath: (workspaceRoot) =>
519 Ref.updateAndGet(faviconCalls, (count) => count + 1).pipe(
520 Effect.as(`${workspaceRoot}/favicon.svg`),
@@ -597,6 +599,7 @@ it.effect("keeps project snapshots available when optional metadata enrichment f
599 resolve: () => Effect.succeed(null),
600 }),
601 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
602 + invalidate: () => Effect.void,
603 resolvePath: (workspaceRoot) =>
604 Effect.fail(
605 new ProjectFaviconResolver.ProjectFaviconResolutionError({
@@ -647,6 +650,7 @@ it.effect("invalidates workspace-derived metadata when a project moves", () =>
650 ),
651 }),
652 Layer.succeed(ProjectFaviconResolver.ProjectFaviconResolver, {
653 + invalidate: () => Effect.void,
654 resolvePath: (workspaceRoot) =>
655 Ref.get(metadataVersion).pipe(
656 Effect.map((version) => `${workspaceRoot}/favicon-v${version}.svg`),
apps/server/src/ws.ts
+3 -4
@@ -2756,10 +2756,9 @@ export const layerWsRpc = (
2756 ...(project.value.faviconPath
2757 ? { projectFaviconPath: project.value.faviconPath }
2758 : {}),
2759 - projectCheckoutPending:
2760 - clone !== null &&
2761 - clone.phase !== "done" &&
2762 - clone.destinationPath === project.value.workspaceRoot,
2759 + ...(clone !== null && clone.destinationPath === project.value.workspaceRoot
2760 + ? { projectCheckout: clone.phase === "done" ? "cloned" : "pending" }
2761 + : {}),
2762 });
2763 }
2764 const thread = yield* threadManagement
apps/web/src/components/AddProjectToMachineDialog.tsx
+33 -1
@@ -1,3 +1,5 @@
1 +import { useParams } from "@tanstack/react-router";
2 +import { scopeProjectRef } from "@t3tools/client-runtime/environment";
3 import {
4 getAddProjectInitialQuery,
5 getCloneDestinationPath,
@@ -13,7 +15,9 @@ import { ArrowRightIcon } from "lucide-react";
15 import { useEffect, useId, useState } from "react";
16 import { create } from "zustand";
17
18 +import { type DraftId, useComposerDraftStore } from "../composerDraftStore";
19 import { useAddProjectTargets } from "../hooks/useAddProjectTargets";
20 +import { useNewThreadHandler } from "../hooks/useHandleNewThread";
21 import { useLogicalProjectEnvironments } from "../hooks/useLogicalProjectEnvironments";
22 import {
23 COPYABLE_FILE_MAX_BYTES,
@@ -71,6 +75,8 @@ export function AddProjectToMachineDialogHost() {
75 function AddProjectToMachineDialog({ request }: { request: AddProjectToMachineRequest }) {
76 const id = useId();
77 const project = useProject(request.projectRef);
78 + const handleNewThread = useNewThreadHandler();
79 + const { draftId: routeDraftId } = useParams({ strict: false });
80 const { environments } = useEnvironments();
81 const targets = useAddProjectTargets(project, useLogicalProjectEnvironments(project, false));
82 const [targetId, setTargetId] = useState(request.targetEnvironmentId);
@@ -128,6 +134,30 @@ function AddProjectToMachineDialog({ request }: { request: AddProjectToMachineRe
134 setSelected(next);
135 };
136
137 + // Lands the user on the new machine right away; its composer shows the clone
138 + // and holds sends until it finishes. A draft open on the source project moves
139 + // over with whatever was typed in it.
140 + const openClonedProject = (targetRef: ScopedProjectRef) => {
141 + const drafts = useComposerDraftStore.getState();
142 + const draftId = routeDraftId as DraftId | undefined;
143 + const draft = draftId ? drafts.getDraftSession(draftId) : null;
144 + if (
145 + draftId &&
146 + draft &&
147 + !draft.promotedTo &&
148 + draft.environmentId === request.projectRef.environmentId &&
149 + draft.projectId === request.projectRef.projectId
150 + ) {
151 + drafts.setDraftThreadContext(draftId, {
152 + projectRef: targetRef,
153 + environmentSelection: "manual",
154 + loadBalancedEnvironmentId: null,
155 + });
156 + return;
157 + }
158 + void handleNewThread(targetRef);
159 + };
160 +
161 const submit = async () => {
162 if (!project || !target || submitting) return;
163 if (destinationPath.trim().length === 0) {
@@ -136,6 +166,7 @@ function AddProjectToMachineDialog({ request }: { request: AddProjectToMachineRe
166 }
167 setSubmitting(true);
168 setError(null);
169 + const projectId = newProjectId();
170 try {
171 await addProjectToMachine({
172 source: { environmentId: project.environmentId, cwd: project.workspaceRoot },
@@ -144,13 +175,14 @@ function AddProjectToMachineDialog({ request }: { request: AddProjectToMachineRe
175 project.workspaceRoot,
176 ),
177 target: { environmentId: target.environmentId, label: target.label },
147 - projectId: newProjectId(),
178 + projectId,
179 title: project.title,
180 remoteUrl,
181 destinationPath: destinationPath.trim(),
182 files: files.filter((file) => selectedFiles.has(file.path)).map((file) => file.path),
183 });
184 close();
185 + openClonedProject(scopeProjectRef(target.environmentId, projectId));
186 } catch (cause) {
187 setError(cause instanceof Error ? cause.message : "Could not start the clone.");
188 setSubmitting(false);
apps/web/src/components/ChatView.tsx
+19 -7
@@ -378,6 +378,7 @@ import { vcsEnvironment } from "../state/vcs";
378 import { sourceControlEnvironment } from "../state/sourceControl";
379 import { useProjectClone } from "../state/projectClones";
380 import { projectCloneDisplayName, projectCloneProgressSummary } from "@t3tools/contracts";
381 +import { dismissProjectFileCopy, useProjectFileCopy } from "../lib/addProjectToMachine";
382 import {
383 type EnvironmentPresentation,
384 useEnvironmentProviders,
@@ -1895,15 +1896,26 @@ export default function ChatView(props: ChatViewProps) {
1896 }
1897 };
1898 const runProjectCloneActionStable = useStableCallback(runProjectCloneAction);
1899 + const activeProjectFileCopy = useProjectFileCopy(activeProjectRef);
1900 const projectCloneSendBlockReason =
1899 - activeProjectClone === null
1900 - ? null
1901 - : activeProjectClone.phase === "running"
1902 - ? "Cloning repository"
1903 - : activeProjectClone.phase === "done"
1904 - ? null
1905 - : "Repository not cloned";
1901 + activeProjectClone?.phase === "running"
1902 + ? "Cloning repository"
1903 + : activeProjectClone !== null && activeProjectClone.phase !== "done"
1904 + ? "Repository not cloned"
1905 + : activeProjectFileCopy?.phase === "copying"
1906 + ? "Copying files"
1907 + : null;
1908 const projectCloneBannerItem = (() => {
1909 + if (activeProjectFileCopy?.phase === "failed" && activeProjectRef) {
1910 + return {
1911 + id: `project-file-copy:${activeProjectRef.projectId}`,
1912 + variant: "error",
1913 + icon: <DownloadIcon />,
1914 + title: activeProjectFileCopy.title,
1915 + description: activeProjectFileCopy.failures.join("\n"),
1916 + onDismiss: () => dismissProjectFileCopy(activeProjectRef),
1917 + };
1918 + }
1919 if (!activeProjectClone || !activeProjectRef || activeProjectClone.phase === "done") {
1920 return null;
1921 }
apps/web/src/components/ProjectCloneToastCoordinator.tsx
+14 -1
@@ -17,7 +17,11 @@ import { useEffect, useRef } from "react";
17 import { useNewThreadHandler } from "../hooks/useHandleNewThread";
18 import { useRemoveClonedProject } from "../hooks/useRemoveClonedProject";
19 import { useEnvironments } from "../state/environments";
20 -import { useEnvironmentProjectClones } from "../state/projectClones";
20 +import {
21 + isProjectCloneToastSilenced,
22 + silenceProjectCloneToasts,
23 + useEnvironmentProjectClones,
24 +} from "../state/projectClones";
25 import { sourceControlEnvironment } from "../state/sourceControl";
26 import { useAtomCommand } from "../state/use-atom-command";
27 import { type DraftId, useComposerDraftStore } from "../composerDraftStore";
@@ -97,11 +101,20 @@ function EnvironmentCloneToasts({ environmentId }: { environmentId: EnvironmentI
101 toastManager.close(current.toastId);
102 toasts.current.delete(clone.projectId);
103 };
104 + const ref = { environmentId, projectId: clone.projectId };
105 if (isViewingProjectDraft(clone.projectId)) {
106 + silenceProjectCloneToasts(ref);
107 closeToast();
108 continue;
109 }
110 if (tracked?.renderedKey === key) continue;
111 + if (
112 + isProjectCloneToastSilenced(ref) &&
113 + (clone.phase === "running" || clone.phase === "done")
114 + ) {
115 + closeToast();
116 + continue;
117 + }
118
119 if (clone.phase === "running") {
120 const options = stackedThreadToast({
apps/web/src/lib/addProjectToMachine.ts
+60 -26
@@ -3,11 +3,17 @@ import {
3 runAtomCommand,
4 squashAtomCommandFailure,
5 } from "@t3tools/client-runtime/state/runtime";
6 -import type { EnvironmentId, ProjectCloneSnapshot, ProjectId } from "@t3tools/contracts";
6 +import { scopedProjectKey } from "@t3tools/client-runtime/environment";
7 +import type {
8 + EnvironmentId,
9 + ProjectCloneSnapshot,
10 + ProjectId,
11 + ScopedProjectRef,
12 +} from "@t3tools/contracts";
13 +import { create } from "zustand";
14
8 -import { stackedThreadToast, toastManager } from "../components/ui/toast";
15 import { appAtomRegistry } from "../rpc/atomRegistry";
10 -import { environmentProjectClonesAtom } from "../state/projectClones";
16 +import { environmentProjectClonesAtom, silenceProjectCloneToasts } from "../state/projectClones";
17 import { projectEnvironment } from "../state/projects";
18 import { sourceControlEnvironment } from "../state/sourceControl";
19
@@ -79,7 +85,7 @@ function failureMessage(result: Parameters<typeof squashAtomCommandFailure>[0]):
85
86 /**
87 * Resolves when the clone finishes, or null once it is removed. A failed or
82 - * cancelled clone keeps waiting, since its toast offers a retry.
88 + * cancelled clone keeps waiting, since the composer offers a retry.
89 */
90 function waitForClone(environmentId: EnvironmentId, projectId: ProjectId) {
91 return new Promise<ProjectCloneSnapshot | null>((resolve) => {
@@ -102,11 +108,36 @@ function waitForClone(environmentId: EnvironmentId, projectId: ProjectId) {
108 });
109 }
110
111 +export type ProjectFileCopy =
112 + | { readonly phase: "copying" }
113 + | { readonly phase: "failed"; readonly title: string; readonly failures: ReadonlyArray<string> };
114 +
115 +/** Ignored-file copies still owed to a cloned project, keyed by its scoped project key. */
116 +const useFileCopies = create<{ copies: Readonly<Record<string, ProjectFileCopy>> }>(() => ({
117 + copies: {},
118 +}));
119 +
120 +function setFileCopy(key: string, copy: ProjectFileCopy | null) {
121 + useFileCopies.setState(({ copies }) => {
122 + const { [key]: _previous, ...rest } = copies;
123 + return { copies: copy === null ? rest : { ...rest, [key]: copy } };
124 + });
125 +}
126 +
127 +/** The composer holds sends until the copy lands, and shows a failed copy until dismissed. */
128 +export function useProjectFileCopy(ref: ScopedProjectRef | null): ProjectFileCopy | null {
129 + return useFileCopies((state) => (ref ? (state.copies[scopedProjectKey(ref)] ?? null) : null));
130 +}
131 +
132 +export function dismissProjectFileCopy(ref: ScopedProjectRef) {
133 + setFileCopy(scopedProjectKey(ref), null);
134 +}
135 +
136 /**
137 * Clones a project onto another machine, then copies the chosen ignored files
138 * from the source. The client relays the files because the two servers never
108 - * talk to each other. Resolves once the clone starts; the clone toast shows
109 - * progress and a second toast reports the copied files.
139 + * talk to each other. Resolves once the clone starts. The caller opens the new
140 + * project, whose composer shows the clone and copy progress, so nothing toasts.
141 */
142 export async function addProjectToMachine(input: AddProjectToMachineInput): Promise<void> {
143 // Read first, so the copy reflects the files as they were when the user asked.
@@ -126,6 +157,11 @@ export async function addProjectToMachine(input: AddProjectToMachineInput): Prom
157 }),
158 );
159
160 + const targetRef = { environmentId: input.target.environmentId, projectId: input.projectId };
161 + const copyKey = scopedProjectKey(targetRef);
162 + // Marked before the start request, since the clone list can arrive before its reply.
163 + silenceProjectCloneToasts(targetRef);
164 + if (reads.length > 0) setFileCopy(copyKey, { phase: "copying" });
165 const started = await runAtomCommand(
166 appAtomRegistry,
167 sourceControlEnvironment.startProjectClone,
@@ -141,14 +177,19 @@ export async function addProjectToMachine(input: AddProjectToMachineInput): Prom
177 },
178 { label: "Add project to machine", reportFailure: false },
179 );
144 - if (started._tag === "Failure") throw new Error(failureMessage(started));
145 - if (input.files.length === 0) return;
180 + if (started._tag === "Failure") {
181 + setFileCopy(copyKey, null);
182 + throw new Error(failureMessage(started));
183 + }
184 + if (reads.length === 0) return;
185
186 void (async () => {
187 const clone = await waitForClone(input.target.environmentId, input.projectId);
149 - if (!clone) return;
188 + if (!clone) {
189 + setFileCopy(copyKey, null);
190 + return;
191 + }
192 const failed: Array<string> = [];
151 - let copied = 0;
193 for (const read of reads) {
194 if (!("contents" in read)) {
195 failed.push(`${read.relativePath}: ${read.error}`);
@@ -171,23 +212,16 @@ export async function addProjectToMachine(input: AddProjectToMachineInput): Prom
212 );
213 if (written._tag === "Failure")
214 failed.push(`${read.relativePath}: ${failureMessage(written)}`);
174 - else copied += 1;
215 }
176 - const noun = (count: number) => (count === 1 ? "file" : "files");
177 - toastManager.add(
178 - stackedThreadToast(
179 - failed.length === 0
180 - ? {
181 - type: "success",
182 - title: `Copied ${copied} ${noun(copied)} to ${input.target.label}`,
183 - description: reads.map((read) => read.relativePath).join(", "),
184 - }
185 - : {
186 - type: "error",
187 - title: `Could not copy ${failed.length} ${noun(failed.length)} to ${input.target.label}`,
188 - description: failed.join("\n"),
189 - },
190 - ),
216 + setFileCopy(
217 + copyKey,
218 + failed.length === 0
219 + ? null
220 + : {
221 + phase: "failed",
222 + title: `Could not copy ${failed.length} ${failed.length === 1 ? "file" : "files"} to ${input.target.label}`,
223 + failures: failed,
224 + },
225 );
226 })();
227 }
apps/web/src/state/projectClones.ts
+15
@@ -41,3 +41,18 @@ export function useEnvironmentProjectClones(
41 ): ReadonlyArray<ProjectCloneSnapshot> {
42 return useAtomValue(environmentProjectClonesAtom(environmentId));
43 }
44 +
45 +const silencedCloneToasts = new Set<string>();
46 +
47 +/**
48 + * Keeps a clone's progress out of toasts once the user is looking at its
49 + * project, whose composer shows the same progress. Failures still toast
50 + * whenever the project is not on screen.
51 + */
52 +export function silenceProjectCloneToasts(ref: ScopedProjectRef) {
53 + silencedCloneToasts.add(scopedProjectKey(ref));
54 +}
55 +
56 +export function isProjectCloneToastSilenced(ref: ScopedProjectRef): boolean {
57 + return silencedCloneToasts.has(scopedProjectKey(ref));
58 +}