fix(desktop): reopen artifact previews after reconnect

Author: SummerC0zyR0ck

apps/desktop/src/main/__tests__/managed-artifact-preview.test.ts

@@ -85,6 +85,8 @@ test('isolates leases by origin and rejects credentials for another preview', as
     await assert.rejects(fetch(first.url));
     assert.equal(await (await fetch(second.url)).text(), 'second');
     await assert.rejects(service.prepare('host1', client(), 's1', 'a1'), /closed/);
+    service.openScope('host1');
+    assert.equal(await (await fetch((await service.prepare('host1', client(), 's1', 'a1')).url)).text(), html);
     await service.revoke('host2', 's1', 'a1');
     await assert.rejects(fetch(second.url));
   } finally { await service.close(); }

apps/desktop/src/main/__tests__/runtime-host-desktop-candidate.test.ts

@@ -523,47 +523,63 @@ test('tears down the whole candidate when the Host connection closes', async ()
   assert.equal(host.closeCalls, 1);
 });
 
-test('closes managed Artifact previews when the Host connection closes', async () => {
+test('closes old managed Artifact previews and reopens the scope after reconnect', async () => {
   const ipc = ipcHarness();
-  const host = connectionHarness('preview-closed');
+  const firstHost = connectionHarness('preview-first');
   const preview = new ManagedArtifactPreview();
   const bytes = Buffer.from('<!doctype html><title>Preview</title>');
-  const candidate = await createDesktopRuntimeHostCandidate(host.connection, {
+  const candidateDeps = {
     ...deps(ipc),
-    registerClientIpc: (_client, _ipc, _controls, _target, scope) =>
-      () => preview.closeScope(scope.targetEpoch),
-  });
+    registerClientIpc: (_client, _ipc, _controls, _target, scope) => {
+      preview.openScope(scope.targetEpoch);
+      return () => preview.closeScope(scope.targetEpoch);
+    },
+  } satisfies DesktopRuntimeHostCandidateDeps;
+  const firstCandidate = await createDesktopRuntimeHostCandidate(firstHost.connection, candidateDeps);
+  let secondCandidate: Awaited<ReturnType<typeof createDesktopRuntimeHostCandidate>> | undefined;
+  const source = {
+    getArtifact: async () => ({
+      id: 'artifact-1',
+      sessionId: 'session-1',
+      turnId: 'turn-1',
+      createdAt: 0,
+      name: 'preview.html',
+      kind: 'html' as const,
+      sizeBytes: bytes.length,
+      source: 'tool_result' as const,
+    }),
+    streamArtifact: async (_sessionId: string, _artifactId: string, write: (chunk: Uint8Array) => Promise<void>) => {
+      await write(bytes);
+      return bytes.length;
+    },
+  };
 
   try {
     const endpoint = await preview.prepare(
       TEST_TARGET_EPOCH,
-      {
-        getArtifact: async () => ({
-          id: 'artifact-1',
-          sessionId: 'session-1',
-          turnId: 'turn-1',
-          createdAt: 0,
-          name: 'preview.html',
-          kind: 'html',
-          sizeBytes: bytes.length,
-          source: 'tool_result',
-        }),
-        streamArtifact: async (_sessionId, _artifactId, write) => {
-          await write(bytes);
-          return bytes.length;
-        },
-      },
+      source,
       'session-1',
       'artifact-1',
     );
     assert.equal(await (await fetch(endpoint.url)).text(), bytes.toString());
 
-    host.disconnect();
-    await candidate.closed;
+    firstHost.disconnect();
+    await firstCandidate.closed;
 
     await assert.rejects(fetch(endpoint.url));
+
+    const secondHost = connectionHarness('preview-second');
+    secondCandidate = await createDesktopRuntimeHostCandidate(secondHost.connection, candidateDeps);
+    const replacement = await preview.prepare(
+      TEST_TARGET_EPOCH,
+      source,
+      'session-1',
+      'artifact-1',
+    );
+    assert.equal(await (await fetch(replacement.url)).text(), bytes.toString());
   } finally {
-    await candidate.close();
+    await firstCandidate.close();
+    await secondCandidate?.close();
     await preview.close();
   }
 });

apps/desktop/src/main/managed-artifact-preview.ts

@@ -56,6 +56,10 @@ export class ManagedArtifactPreview {
 
   constructor(private readonly ttlMs = PREVIEW_TTL_MS) {}
 
+  openScope(scope: string): void {
+    this.retiredScopes.delete(scope);
+  }
+
   async releaseUrl(url: string): Promise<void> {
     const lease = [...this.leases].find((entry) => entry.url === url);
     if (lease) await this.release(lease);

apps/desktop/src/main/runtime-host-boot.ts

@@ -1835,6 +1835,7 @@ function registerHostClientIpc(
   });
   registerOnboardingIpc({ onboardingService, ipcMain: scopedIpc });
   registerTaskSubmissionReadinessIpc(taskSubmissionReadinessService, scopedIpc);
+  managedArtifactPreview.openScope(scope.targetEpoch);
   return async () => {
     clientPluginTransport.release(client);
     unsubscribeConfigurationChanges();