feat(desktop): import browser cookies into a profile

apps/desktop/package.json

@@ -15,6 +15,7 @@
     "@clerk/electron": "catalog:",
     "@clerk/electron-passkeys": "catalog:",
     "@effect/platform-node": "catalog:",
+    "@napi-rs/keyring": "^1.3.0",
     "@t3tools/client-runtime": "workspace:*",
     "@t3tools/contracts": "workspace:*",
     "@t3tools/shared": "workspace:*",

apps/desktop/src/ipc/DesktopIpcHandlers.ts

@@ -97,4 +97,6 @@ export const installDesktopIpcHandlers = Effect.fn("desktop.ipc.installHandlers"
   for (const previewMethod of PreviewIpc.methods) {
     yield* ipc.handle(previewMethod);
   }
+  yield* ipc.handle(PreviewIpc.listBrowserImportSources);
+  yield* ipc.handle(PreviewIpc.importBrowserCookies);
 });

apps/desktop/src/ipc/channels.ts

@@ -60,6 +60,8 @@ export const PREVIEW_OPEN_DEVTOOLS_CHANNEL = "desktop:preview-open-devtools";
 export const PREVIEW_CLEAR_COOKIES_CHANNEL = "desktop:preview-clear-cookies";
 export const PREVIEW_CLEAR_CACHE_CHANNEL = "desktop:preview-clear-cache";
 export const PREVIEW_GET_CONFIG_CHANNEL = "desktop:preview-get-config";
+export const PREVIEW_IMPORT_SOURCES_CHANNEL = "desktop:preview-import-sources";
+export const PREVIEW_IMPORT_COOKIES_CHANNEL = "desktop:preview-import-cookies";
 export const PREVIEW_SET_ANNOTATION_THEME_CHANNEL = "desktop:preview-set-annotation-theme";
 export const PREVIEW_PICK_ELEMENT_CHANNEL = "desktop:preview-pick-element";
 export const PREVIEW_CANCEL_PICK_ELEMENT_CHANNEL = "desktop:preview-cancel-pick-element";

apps/desktop/src/ipc/methods/preview.test.ts

@@ -12,6 +12,7 @@ import * as Schema from "effect/Schema";
 import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
 
 import * as PreviewManager from "../../preview/Manager.ts";
+import * as BrowserImport from "../../preview/BrowserImport/BrowserImport.ts";
 import * as PreviewIpc from "./preview.ts";
 
 const { fromPartition } = vi.hoisted(() => ({
@@ -80,6 +81,38 @@ describe("preview IPC methods", () => {
     });
   });
 
+  effectIt.effect("targets imports at the same partition tuple as the renderer", () => {
+    const received: Array<Parameters<BrowserImport.BrowserImport["Service"]["importCookies"]>[0]> =
+      [];
+    const browserImport = BrowserImport.BrowserImport.of({
+      listSources: Effect.succeed([]),
+      importCookies: (input) =>
+        Effect.sync(() => {
+          received.push(input);
+          return { imported: 0, skipped: 0, skippedDomains: [] };
+        }),
+    });
+    const request = (environmentId: string, targetProfileId: string) =>
+      PreviewIpc.importBrowserCookies.handler({
+        environmentId,
+        sourceId: "helium",
+        sourceProfileDirectory: "Default",
+        targetProfileId,
+      });
+
+    return Effect.gen(function* () {
+      yield* request("a", "b");
+      yield* request("a::b", DEFAULT_BROWSER_PROFILE_ID);
+
+      expect(received[0]).toMatchObject(PreviewIpc.resolvePartitionScope("a", "b"));
+      expect(received[1]).toMatchObject(
+        PreviewIpc.resolvePartitionScope("a::b", DEFAULT_BROWSER_PROFILE_ID),
+      );
+      expect(received[0]?.namespace).toBe("profile");
+      expect(received[1]?.namespace).toBeUndefined();
+    }).pipe(Effect.provideService(BrowserImport.BrowserImport, browserImport));
+  });
+
   effectIt.effect("rejects invalid webContents ids before resolving the preview service", () =>
     Effect.map(
       PreviewIpc.registerWebview

apps/desktop/src/ipc/methods/preview.ts

@@ -16,7 +16,10 @@ import {
   DesktopPreviewScreenshotArtifactSchema,
   DesktopPreviewSetAudioMutedInputSchema,
   DesktopPreviewSetColorSchemeInputSchema,
+  BrowserImportResult,
+  BrowserImportSource,
   DesktopPreviewClearDataInputSchema,
+  DesktopPreviewImportCookiesInputSchema,
   DesktopPreviewCreateTabInputSchema,
   DesktopPreviewTabInputSchema,
   DesktopPreviewWebviewConfigSchema,
@@ -30,6 +33,7 @@ import * as Schema from "effect/Schema";
 import * as NodeURL from "node:url";
 
 import * as ElectronWindow from "../../electron/ElectronWindow.ts";
+import * as BrowserImport from "../../preview/BrowserImport/BrowserImport.ts";
 import * as PreviewManager from "../../preview/Manager.ts";
 import { PREVIEW_WEBVIEW_PREFERENCES } from "../../preview/WebviewPreferences.ts";
 import * as IpcChannels from "../channels.ts";
@@ -284,6 +288,45 @@ export const getPreviewConfig = DesktopIpc.makeIpcMethod({
   }),
 });
 
+/**
+ * Registered separately from `methods`: these carry `BrowserImport` in their
+ * context and their own failure type, so they do not unify with the
+ * manager-backed handlers the shared loop iterates.
+ */
+export const listBrowserImportSources = DesktopIpc.makeIpcMethod({
+  channel: IpcChannels.PREVIEW_IMPORT_SOURCES_CHANNEL,
+  payload: Schema.Void,
+  result: Schema.Array(BrowserImportSource),
+  handler: Effect.fn("desktop.ipc.preview.listBrowserImportSources")(function* () {
+    const browserImport = yield* BrowserImport.BrowserImport;
+    return yield* browserImport.listSources;
+  }),
+});
+
+export const importBrowserCookies = DesktopIpc.makeIpcMethod({
+  channel: IpcChannels.PREVIEW_IMPORT_COOKIES_CHANNEL,
+  payload: DesktopPreviewImportCookiesInputSchema,
+  result: BrowserImportResult,
+  handler: Effect.fn("desktop.ipc.preview.importBrowserCookies")(function* ({
+    environmentId,
+    ...importInput
+  }) {
+    const browserImport = yield* BrowserImport.BrowserImport;
+    // Derived in main from the same helper the webview config uses, so cookies
+    // land in exactly the partition the profile's tabs attach to.
+    const { scope, persistent, namespace } = resolvePartitionScope(
+      environmentId,
+      importInput.targetProfileId,
+    );
+    return yield* browserImport.importCookies({
+      input: importInput,
+      scope,
+      persistent,
+      ...(namespace === undefined ? {} : { namespace }),
+    });
+  }),
+});
+
 export const setAnnotationTheme = DesktopIpc.makeIpcMethod({
   channel: IpcChannels.PREVIEW_SET_ANNOTATION_THEME_CHANNEL,
   payload: DesktopPreviewAnnotationThemeInputSchema,

apps/desktop/src/main.ts

@@ -57,6 +57,7 @@ import * as DesktopSshPasswordPrompts from "./ssh/DesktopSshPasswordPrompts.ts";
 import * as DesktopState from "./app/DesktopState.ts";
 import * as DesktopTelemetryPublisher from "./telemetry/DesktopTelemetryPublisher.ts";
 import * as DesktopUpdates from "./updates/DesktopUpdates.ts";
+import * as BrowserImport from "./preview/BrowserImport/BrowserImport.ts";
 import * as BrowserSession from "./preview/BrowserSession.ts";
 import * as PreviewManager from "./preview/Manager.ts";
 import * as DesktopWindow from "./window/DesktopWindow.ts";
@@ -148,6 +149,9 @@ const desktopServerExposureLayer = DesktopServerExposure.layer.pipe(
 );
 
 const desktopPreviewLayer = PreviewManager.layer.pipe(
+  // Merged rather than provided so the IPC handlers can reach the import
+  // service alongside the manager; both sit on the same BrowserSession.
+  Layer.provideMerge(BrowserImport.layer),
   Layer.provideMerge(BrowserSession.layer),
   Layer.provideMerge(desktopFoundationLayer),
 );

apps/desktop/src/preload.ts

@@ -193,6 +193,9 @@ contextBridge.exposeInMainWorld("desktopBridge", {
       ipcRenderer.invoke(IpcChannels.PREVIEW_SET_AUDIO_MUTED_CHANNEL, { tabId, audioMuted }),
     openDevTools: (tabId) =>
       ipcRenderer.invoke(IpcChannels.PREVIEW_OPEN_DEVTOOLS_CHANNEL, { tabId }),
+    listBrowserImportSources: () => ipcRenderer.invoke(IpcChannels.PREVIEW_IMPORT_SOURCES_CHANNEL),
+    importBrowserCookies: (input) =>
+      ipcRenderer.invoke(IpcChannels.PREVIEW_IMPORT_COOKIES_CHANNEL, input),
     clearCookies: (environmentId, profileId) =>
       ipcRenderer.invoke(IpcChannels.PREVIEW_CLEAR_COOKIES_CHANNEL, { environmentId, profileId }),
     clearCache: (environmentId, profileId) =>

apps/desktop/src/preview/BrowserImport/BrowserImport.test.ts

@@ -0,0 +1,177 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, describe, it } from "@effect/vitest";
+import {
+  HostProcessEnvironment,
+  HostProcessExecutablePath,
+  HostProcessPlatform,
+} from "@t3tools/shared/hostProcess";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Fiber from "effect/Fiber";
+import * as Layer from "effect/Layer";
+import * as Ref from "effect/Ref";
+
+import * as BrowserSession from "../BrowserSession.ts";
+import * as BrowserImport from "./BrowserImport.ts";
+import { BROWSER_IMPORT_SOURCES, sourcePaths } from "./Sources.ts";
+
+const helium = BROWSER_IMPORT_SOURCES.find((source) => source.id === "helium")!;
+
+const cookie = {
+  url: "https://rejected.example/path",
+  name: "session",
+  value: "value",
+  domain: undefined,
+  path: "/",
+  secure: true,
+  httpOnly: true,
+  expirationDate: undefined,
+  sameSite: "lax" as const,
+};
+
+/**
+ * Dies if the import reaches session work: every case here covers a request
+ * that must be rejected before a cookie is read or written.
+ */
+const rejectedBeforeSession = Layer.succeed(
+  BrowserSession.BrowserSession,
+  BrowserSession.BrowserSession.of({
+    getPartition: () => Effect.die("getPartition must not be reached"),
+    isPartition: () => false,
+    getSession: () => Effect.die("getSession must not be reached"),
+    clearCookies: () => Effect.die("clearCookies must not be reached"),
+    clearCache: () => Effect.die("clearCache must not be reached"),
+  }),
+);
+
+/**
+ * Builds the service against a scratch home containing an installed, closed
+ * copy of the source browser.
+ */
+const withImporter = Effect.fnUntraced(function* () {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const home = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3code-import-" });
+  const environment = Layer.succeed(HostProcessEnvironment, { HOME: home });
+  const paths = yield* sourcePaths.pipe(
+    Effect.provideService(HostProcessEnvironment, { HOME: home }),
+  );
+  yield* fileSystem.makeDirectory(`${helium.userDataDirectory(paths)}/Default`, {
+    recursive: true,
+  });
+  // The cookie database is what marks a source as installed, so a fixture
+  // without one is reported as absent before any other check runs.
+  yield* fileSystem.writeFileString(`${helium.userDataDirectory(paths)}/Default/Cookies`, "db");
+
+  const importer = yield* BrowserImport.BrowserImport.pipe(
+    Effect.provide(
+      BrowserImport.layer.pipe(
+        Layer.provide(rejectedBeforeSession),
+        Layer.provide(environment),
+        Layer.provide(Layer.succeed(HostProcessPlatform, "darwin")),
+        Layer.provide(Layer.succeed(HostProcessExecutablePath, "/Applications/T3 Code.app")),
+        Layer.provide(NodeServices.layer),
+      ),
+    ),
+  );
+  return { importer, home, paths };
+});
+
+describe("BrowserImport.importCookies", () => {
+  it.effect("rejects a source profile the browser never reported", () =>
+    Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      const { importer, home } = yield* withImporter();
+
+      // A cookie database reachable on disk but outside the browser's
+      // user-data directory — the payoff a traversal would be after.
+      yield* fileSystem.makeDirectory(`${home}/secrets`, { recursive: true });
+      yield* fileSystem.writeFileString(`${home}/secrets/Cookies`, "not-a-db");
+
+      const error = yield* importer
+        .importCookies({
+          input: {
+            sourceId: "helium",
+            sourceProfileDirectory: "../../../../secrets",
+            targetProfileId: "default",
+          },
+          scope: "persist:t3code-preview-test",
+          persistent: true,
+        })
+        .pipe(Effect.flip);
+
+      assert.instanceOf(error, BrowserImport.BrowserImportFailedError);
+      assert.equal(error.reason, "unknownSourceProfile");
+    }).pipe(Effect.provide(NodeServices.layer), Effect.scoped),
+  );
+
+  it.effect("refuses to import while the source browser holds its profile", () =>
+    Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      const { importer, paths } = yield* withImporter();
+      // The lock Chromium leaves while it is running, dangling target and
+      // all. This must stop the import before it ever asks the keychain.
+      yield* fileSystem.symlink(
+        "host-that-does-not-exist-1234",
+        `${helium.userDataDirectory(paths)}/SingletonLock`,
+      );
+
+      const error = yield* importer
+        .importCookies({
+          input: {
+            sourceId: "helium",
+            sourceProfileDirectory: "Default",
+            targetProfileId: "default",
+          },
+          scope: "persist:t3code-preview-test",
+          persistent: true,
+        })
+        .pipe(Effect.flip);
+
+      assert.equal(error.reason, "browserRunning");
+    }).pipe(Effect.provide(NodeServices.layer), Effect.scoped),
+  );
+});
+
+describe("BrowserImport.writeCookies", () => {
+  it.effect("counts a rejected cookie and its domain as skipped", () =>
+    Effect.gen(function* () {
+      const result = yield* BrowserImport.writeCookies(
+        {
+          cookies: {
+            set: () => Promise.reject(new Error("fixture rejection")),
+          },
+        },
+        { cookies: [cookie], undecryptable: 0, undecryptableHosts: [] },
+      );
+
+      assert.deepEqual(result, {
+        imported: 0,
+        skipped: 1,
+        skippedDomains: ["rejected.example"],
+      });
+    }),
+  );
+
+  it.effect("propagates interruption while writing a cookie", () =>
+    Effect.gen(function* () {
+      const write = BrowserImport.writeCookies(
+        {
+          cookies: {
+            set: () => new Promise<void>(() => {}),
+          },
+        },
+        { cookies: [cookie], undecryptable: 0, undecryptableHosts: [] },
+      );
+
+      const interrupted = yield* Ref.make(false);
+      const fiber = yield* write.pipe(
+        Effect.onInterrupt(() => Ref.set(interrupted, true)),
+        Effect.forkChild,
+      );
+      yield* Effect.yieldNow;
+      yield* Fiber.interrupt(fiber);
+
+      assert.isTrue(yield* Ref.get(interrupted));
+    }),
+  );
+});