From f108f497eab5ae87502a526de639b03cb76f0c2c Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 09:30:30 +0200
Subject: [PATCH 01/24] feat(accounts): add encrypted account export/import
 module

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/main/accounts/accountTransfer.test.ts |  60 ++++++++++++
 src/main/accounts/accountTransfer.ts      | 106 ++++++++++++++++++++++
 2 files changed, 166 insertions(+)
 create mode 100644 src/main/accounts/accountTransfer.test.ts
 create mode 100644 src/main/accounts/accountTransfer.ts

diff --git a/src/main/accounts/accountTransfer.test.ts b/src/main/accounts/accountTransfer.test.ts
new file mode 100644
index 0000000..690303e
--- /dev/null
+++ b/src/main/accounts/accountTransfer.test.ts
@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { exportAccounts, importAccounts, TransferError, type ExportAccount } from './accountTransfer';
+
+const acc: ExportAccount = {
+  label: 'AWS prod', provider: 'amazon-s3', region: 'eu-central-1',
+  accessKeyId: 'AK', secretAccessKey: 'SECRET',
+};
+const custom: ExportAccount = {
+  label: 'MinIO', provider: 'custom', region: 'us-east-1',
+  accessKeyId: 'CK', secretAccessKey: 'CS', endpoint: 'https://minio.example.com', forcePathStyle: true,
+};
+
+describe('accountTransfer round-trip', () => {
+  it('exports and imports without a password (unencrypted)', () => {
+    const blob = exportAccounts([acc]);
+    expect(importAccounts(blob)).toEqual([acc]);
+  });
+
+  it('exports and imports with a password', () => {
+    const blob = exportAccounts([acc, custom], 'hunter2');
+    expect(importAccounts(blob, 'hunter2')).toEqual([acc, custom]);
+  });
+
+  it('produces different ciphertext each time (random salt/iv)', () => {
+    expect(exportAccounts([acc], 'pw')).not.toEqual(exportAccounts([acc], 'pw'));
+  });
+});
+
+describe('accountTransfer errors', () => {
+  it('throws IncorrectPassword for a wrong password', () => {
+    const blob = exportAccounts([acc], 'right');
+    expect(() => importAccounts(blob, 'wrong')).toThrow(expect.objectContaining({ code: 'IncorrectPassword' }));
+  });
+
+  it('throws PasswordRequired when an encrypted blob is imported without a password', () => {
+    const blob = exportAccounts([acc], 'pw');
+    expect(() => importAccounts(blob)).toThrow(expect.objectContaining({ code: 'PasswordRequired' }));
+  });
+
+  it('throws InvalidData for non-base64 / non-JSON garbage', () => {
+    expect(() => importAccounts('!!!not-base64!!!')).toThrow(expect.objectContaining({ code: 'InvalidData' }));
+  });
+
+  it('throws InvalidData for a JSON blob that is not our format', () => {
+    const notOurs = Buffer.from(JSON.stringify({ hello: 'world' }), 'utf8').toString('base64');
+    expect(() => importAccounts(notOurs)).toThrow(expect.objectContaining({ code: 'InvalidData' }));
+  });
+
+  it('throws IncorrectPassword when the ciphertext is tampered', () => {
+    const blob = exportAccounts([acc], 'pw');
+    const env = JSON.parse(Buffer.from(blob, 'base64').toString('utf8'));
+    env.data = Buffer.from('tampered-ciphertext').toString('base64');
+    const tampered = Buffer.from(JSON.stringify(env), 'utf8').toString('base64');
+    expect(() => importAccounts(tampered, 'pw')).toThrow(expect.objectContaining({ code: 'IncorrectPassword' }));
+  });
+
+  it('exposes TransferError with a code', () => {
+    expect(new TransferError('InvalidData', 'x').code).toBe('InvalidData');
+  });
+});
diff --git a/src/main/accounts/accountTransfer.ts b/src/main/accounts/accountTransfer.ts
new file mode 100644
index 0000000..b34b6d8
--- /dev/null
+++ b/src/main/accounts/accountTransfer.ts
@@ -0,0 +1,106 @@
+import { randomBytes, scryptSync, createCipheriv, createDecipheriv } from 'node:crypto';
+import type { ProviderId } from '../s3/providers';
+
+export interface ExportAccount {
+  label: string;
+  provider: ProviderId;
+  region: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  endpoint?: string;
+  forcePathStyle?: boolean;
+}
+
+export type TransferErrorCode = 'PasswordRequired' | 'IncorrectPassword' | 'InvalidData';
+
+export class TransferError extends Error {
+  constructor(public readonly code: TransferErrorCode, message: string) {
+    super(message);
+    this.name = 'TransferError';
+  }
+}
+
+const FORMAT = 's3manager-accounts';
+const VERSION = 1;
+const SCRYPT = { N: 32768, r: 8, p: 1 };
+const KEYLEN = 32;
+
+function deriveKey(password: string, salt: Buffer): Buffer {
+  // maxmem must be set explicitly: Node.js defaults to 32 MB, which is exactly
+  // the lower bound for N=32768, r=8. 64 MB gives comfortable headroom.
+  return scryptSync(password, salt, KEYLEN, { N: SCRYPT.N, r: SCRYPT.r, p: SCRYPT.p, maxmem: 67108864 });
+}
+
+export function exportAccounts(accounts: ExportAccount[], password?: string): string {
+  const payload = JSON.stringify({ accounts });
+  let envelope: Record<string, unknown>;
+  if (password && password.length > 0) {
+    const salt = randomBytes(16);
+    const iv = randomBytes(12);
+    const cipher = createCipheriv('aes-256-gcm', deriveKey(password, salt), iv);
+    const ciphertext = Buffer.concat([cipher.update(payload, 'utf8'), cipher.final()]);
+    envelope = {
+      format: FORMAT,
+      version: VERSION,
+      encrypted: true,
+      kdf: { name: 'scrypt', N: SCRYPT.N, r: SCRYPT.r, p: SCRYPT.p, salt: salt.toString('base64') },
+      cipher: 'aes-256-gcm',
+      iv: iv.toString('base64'),
+      tag: cipher.getAuthTag().toString('base64'),
+      data: ciphertext.toString('base64'),
+    };
+  } else {
+    envelope = { format: FORMAT, version: VERSION, encrypted: false, data: payload };
+  }
+  return Buffer.from(JSON.stringify(envelope), 'utf8').toString('base64');
+}
+
+export function importAccounts(blob: string, password?: string): ExportAccount[] {
+  let env: Record<string, unknown>;
+  try {
+    const json = Buffer.from(blob.trim(), 'base64').toString('utf8');
+    const parsed: unknown = JSON.parse(json);
+    if (typeof parsed !== 'object' || parsed === null) throw new Error('not an object');
+    env = parsed as Record<string, unknown>;
+  } catch {
+    throw new TransferError('InvalidData', 'The import data is not valid.');
+  }
+  if (env.format !== FORMAT || env.version !== VERSION || typeof env.data !== 'string') {
+    throw new TransferError('InvalidData', 'The import data is not a recognized account export.');
+  }
+
+  let payload: string;
+  if (env.encrypted === true) {
+    if (!password || password.length === 0) {
+      throw new TransferError('PasswordRequired', 'This export is password-protected.');
+    }
+    try {
+      const kdf = env.kdf as { salt: string };
+      const salt = Buffer.from(kdf.salt, 'base64');
+      const iv = Buffer.from(env.iv as string, 'base64');
+      const tag = Buffer.from(env.tag as string, 'base64');
+      const decipher = createDecipheriv('aes-256-gcm', deriveKey(password, salt), iv);
+      decipher.setAuthTag(tag);
+      payload = Buffer.concat([
+        decipher.update(Buffer.from(env.data as string, 'base64')),
+        decipher.final(),
+      ]).toString('utf8');
+    } catch {
+      throw new TransferError('IncorrectPassword', 'Incorrect password or corrupted data.');
+    }
+  } else {
+    payload = env.data;
+  }
+
+  let parsedPayload: unknown;
+  try {
+    parsedPayload = JSON.parse(payload);
+  } catch {
+    throw new TransferError('InvalidData', 'The import payload is malformed.');
+  }
+  const accounts = (parsedPayload as { accounts?: unknown }).accounts;
+  if (!Array.isArray(accounts)) {
+    throw new TransferError('InvalidData', 'The import payload has no accounts.');
+  }
+  return accounts as ExportAccount[];
+}

From 6eeb32a7f6e654552cf7d1ab971d4d4339ff71c5 Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 09:36:26 +0200
Subject: [PATCH 02/24] feat(ipc): add saveTextFile/openTextFile helpers

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/main.ts                   | 20 +++++++++++++++++++-
 src/main/ipc/channels.ts      |  4 ++++
 src/main/ipc/register.test.ts | 19 +++++++++++++++++++
 src/main/ipc/register.ts      | 12 ++++++++++++
 src/preload.ts                |  2 ++
 5 files changed, 56 insertions(+), 1 deletion(-)

diff --git a/src/main.ts b/src/main.ts
index 300f0e4..518e897 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -1,5 +1,6 @@
 import { app, BrowserWindow, ipcMain, safeStorage, dialog, shell, nativeTheme } from 'electron';
 import path from 'node:path';
+import { readFile, writeFile } from 'node:fs/promises';
 import started from 'electron-squirrel-startup';
 import { openDatabase } from './main/storage/db';
 import { createAccountsRepo } from './main/storage/accountsRepo';
@@ -31,11 +32,28 @@ function initBackend() {
       : await dialog.showOpenDialog({ properties: ['openDirectory'] });
     return result.canceled || !result.filePaths[0] ? null : result.filePaths[0];
   };
+  const saveTextFile = async (defaultName: string, contents: string): Promise<boolean> => {
+    const win = BrowserWindow.getFocusedWindow();
+    const result = win
+      ? await dialog.showSaveDialog(win, { defaultPath: defaultName })
+      : await dialog.showSaveDialog({ defaultPath: defaultName });
+    if (result.canceled || !result.filePath) return false;
+    await writeFile(result.filePath, contents, 'utf8');
+    return true;
+  };
+  const openTextFile = async (): Promise<string | null> => {
+    const win = BrowserWindow.getFocusedWindow();
+    const result = win
+      ? await dialog.showOpenDialog(win, { properties: ['openFile'] })
+      : await dialog.showOpenDialog({ properties: ['openFile'] });
+    if (result.canceled || !result.filePaths[0]) return null;
+    return readFile(result.filePaths[0], 'utf8');
+  };
   const applyTheme = (theme: 'system' | 'light' | 'dark') => {
     nativeTheme.themeSource = theme;
   };
   applyTheme(readSettings(settings).theme); // honor the persisted choice at launch
-  registerIpc(ipcMain, { accounts, settings, secrets, crypto: safeStorage, db, saveDialog, selectDirectory, appVersion: app.getVersion(), openExternal: (url) => shell.openExternal(url), applyTheme });
+  registerIpc(ipcMain, { accounts, settings, secrets, crypto: safeStorage, db, saveDialog, selectDirectory, saveTextFile, openTextFile, appVersion: app.getVersion(), openExternal: (url) => shell.openExternal(url), applyTheme });
 }
 
 const createWindow = () => {
diff --git a/src/main/ipc/channels.ts b/src/main/ipc/channels.ts
index 6d361eb..38bb0c0 100644
--- a/src/main/ipc/channels.ts
+++ b/src/main/ipc/channels.ts
@@ -54,6 +54,8 @@ export const CH = {
   setSettings: 'settings:set',
   getAppInfo: 'app:getInfo',
   openExternal: 'shell:openExternal',
+  saveTextFile: 'util:saveTextFile',
+  openTextFile: 'util:openTextFile',
   checkForUpdate: 'app:checkForUpdate',
   getObjectAcl: 's3:getObjectAcl',
   putObjectAcl: 's3:putObjectAcl',
@@ -139,6 +141,8 @@ export interface ApiMap {
   [CH.setSettings]: { args: [Partial<AppSettings>]; res: Result<AppSettings> };
   [CH.getAppInfo]: { args: []; res: Result<AppInfo> };
   [CH.openExternal]: { args: [string]; res: Result<true> };
+  [CH.saveTextFile]: { args: [{ defaultName: string; contents: string }]; res: Result<{ saved: boolean }> };
+  [CH.openTextFile]: { args: []; res: Result<string | null> };
   [CH.checkForUpdate]: { args: []; res: Result<UpdateInfo> };
   [CH.getObjectAcl]: { args: [{ accountId: string; bucket: string; key: string }]; res: Result<ObjectAcl> };
   [CH.putObjectAcl]: { args: [{ accountId: string; bucket: string; key: string; acl: ObjectAcl }]; res: Result<true> };
diff --git a/src/main/ipc/register.test.ts b/src/main/ipc/register.test.ts
index 64aa969..893702c 100644
--- a/src/main/ipc/register.test.ts
+++ b/src/main/ipc/register.test.ts
@@ -41,6 +41,8 @@ function buildHarness(overrides: Record<string, unknown> = {}) {
     db,
     saveDialog: vi.fn().mockResolvedValue(null),
     selectDirectory: vi.fn().mockResolvedValue('/picked/dir'),
+    saveTextFile: vi.fn().mockResolvedValue(false),
+    openTextFile: vi.fn().mockResolvedValue(null),
     appVersion: '1.2.3',
     openExternal: vi.fn().mockResolvedValue(undefined),
     ...overrides,
@@ -57,6 +59,21 @@ describe('registerIpc', () => {
     }
   });
 
+  it('util:saveTextFile delegates to the injected saveTextFile helper', async () => {
+    const saveTextFile = vi.fn().mockResolvedValue(true);
+    const { handlers } = buildHarness({ saveTextFile });
+    const res = (await handlers.get(CH.saveTextFile)!({ defaultName: 'x.txt', contents: 'hi' })) as { ok: boolean; data: { saved: boolean } };
+    expect(saveTextFile).toHaveBeenCalledWith('x.txt', 'hi');
+    expect(res).toEqual({ ok: true, data: { saved: true } });
+  });
+
+  it('util:openTextFile delegates to the injected openTextFile helper', async () => {
+    const openTextFile = vi.fn().mockResolvedValue('file-contents');
+    const { handlers } = buildHarness({ openTextFile });
+    const res = (await handlers.get(CH.openTextFile)!()) as { ok: boolean; data: string | null };
+    expect(res).toEqual({ ok: true, data: 'file-contents' });
+  });
+
   it('shell:openExternal opens http(s) urls', async () => {
     const { handlers, deps } = buildHarness();
     const res = await handlers.get(CH.openExternal)!('https://github.com/facebook/react');
@@ -232,6 +249,8 @@ describe('registerIpc', () => {
       db,
       saveDialog: vi.fn().mockResolvedValue(null),
       selectDirectory: vi.fn().mockResolvedValue('/picked/dir'),
+      saveTextFile: vi.fn().mockResolvedValue(false),
+      openTextFile: vi.fn().mockResolvedValue(null),
       appVersion: '1.2.3',
       openExternal: vi.fn().mockResolvedValue(undefined),
     };
diff --git a/src/main/ipc/register.ts b/src/main/ipc/register.ts
index 06c5e42..319e760 100644
--- a/src/main/ipc/register.ts
+++ b/src/main/ipc/register.ts
@@ -53,6 +53,10 @@ export interface RegisterDeps {
   saveDialog: (defaultFileName: string) => Promise<string | null>;
   /** Shows a native folder picker; resolves the chosen directory, or null if cancelled. */
   selectDirectory: () => Promise<string | null>;
+  /** Saves text to a user-chosen file; resolves true if saved, false if cancelled. Injected by main.ts. */
+  saveTextFile: (defaultName: string, contents: string) => Promise<boolean>;
+  /** Opens a user-chosen text file and resolves its contents, or null if cancelled. Injected by main.ts. */
+  openTextFile: () => Promise<string | null>;
   /** The app version string (Electron app.getVersion()), injected by main.ts. */
   appVersion: string;
   /** Opens a URL in the user's default browser (Electron shell.openExternal), injected by main.ts. */
@@ -390,6 +394,14 @@ export function registerIpc(ipcMain: IpcMainLike, deps: RegisterDeps): void {
       accountCount: deps.accounts.list().length,
     }),
   );
+
+  h(CH.saveTextFile, async (a: { defaultName: string; contents: string }) => {
+    const saved = await deps.saveTextFile(a.defaultName, a.contents);
+    return ok({ saved });
+  });
+
+  h(CH.openTextFile, async () => ok(await deps.openTextFile()));
+
   h(CH.checkForUpdate, () =>
     checkForUpdate({ fetchImpl: deps.fetchImpl ?? globalThis.fetch, currentVersion: deps.appVersion }),
   );
diff --git a/src/preload.ts b/src/preload.ts
index d971be8..0fb9777 100644
--- a/src/preload.ts
+++ b/src/preload.ts
@@ -56,6 +56,8 @@ const api = {
   getEditableMetadata: (a: ApiMap[typeof CH.getEditableMetadata]['args'][0]) => invoke(CH.getEditableMetadata, a),
   updateObjectMetadata: (a: ApiMap[typeof CH.updateObjectMetadata]['args'][0]) => invoke(CH.updateObjectMetadata, a),
   openExternal: (url: string) => invoke(CH.openExternal, url),
+  saveTextFile: (a: ApiMap[typeof CH.saveTextFile]['args'][0]) => invoke(CH.saveTextFile, a),
+  openTextFile: () => invoke(CH.openTextFile),
   onSyncProgress: (cb: (p: SyncProgress) => void) => {
     const listener = (_event: unknown, payload: unknown) => cb(payload as SyncProgress);
     ipcRenderer.on(SYNC_PROGRESS_CHANNEL, listener);

From c03d078797a09c77392abd0ff29e37e5ebfe98b5 Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 09:39:49 +0200
Subject: [PATCH 03/24] test(ipc): assert openTextFile delegation

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/main/ipc/register.test.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/main/ipc/register.test.ts b/src/main/ipc/register.test.ts
index 893702c..de79455 100644
--- a/src/main/ipc/register.test.ts
+++ b/src/main/ipc/register.test.ts
@@ -71,6 +71,7 @@ describe('registerIpc', () => {
     const openTextFile = vi.fn().mockResolvedValue('file-contents');
     const { handlers } = buildHarness({ openTextFile });
     const res = (await handlers.get(CH.openTextFile)!()) as { ok: boolean; data: string | null };
+    expect(openTextFile).toHaveBeenCalledTimes(1);
     expect(res).toEqual({ ok: true, data: 'file-contents' });
   });
 

From 61a4472a068aa4d89c2a7e6892c6515e941243d0 Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 09:42:36 +0200
Subject: [PATCH 04/24] feat(ipc): add accounts export/import channels

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/main/ipc/channels.ts      |  4 +++
 src/main/ipc/register.test.ts | 37 ++++++++++++++++++++++
 src/main/ipc/register.ts      | 59 +++++++++++++++++++++++++++++++++++
 src/preload.ts                |  2 ++
 4 files changed, 102 insertions(+)

diff --git a/src/main/ipc/channels.ts b/src/main/ipc/channels.ts
index 38bb0c0..0809057 100644
--- a/src/main/ipc/channels.ts
+++ b/src/main/ipc/channels.ts
@@ -19,6 +19,8 @@ export const CH = {
   accountsUpdate: 'accounts:update',
   accountsRemove: 'accounts:remove',
   accountsTest: 'accounts:test',
+  accountsExport: 'accounts:export',
+  accountsImport: 'accounts:import',
   encryptionAvailable: 'secrets:available',
   listBuckets: 's3:listBuckets',
   createBucket: 's3:createBucket',
@@ -106,6 +108,8 @@ export interface ApiMap {
   [CH.accountsUpdate]: { args: [UpdateAccountInput]; res: Result<Account> };
   [CH.accountsRemove]: { args: [string]; res: Result<true> };
   [CH.accountsTest]: { args: [TestAccountInput]; res: Result<true> };
+  [CH.accountsExport]: { args: [{ accountIds: string[]; password?: string }]; res: Result<string> };
+  [CH.accountsImport]: { args: [{ blob: string; password?: string }]; res: Result<Account[]> };
   [CH.encryptionAvailable]: { args: []; res: Result<boolean> };
   [CH.listBuckets]: { args: [string]; res: Result<string[]> };
   [CH.createBucket]: { args: [{ accountId: string; bucket: string; objectLock: boolean; versioning: boolean }]; res: Result<true> };
diff --git a/src/main/ipc/register.test.ts b/src/main/ipc/register.test.ts
index de79455..430a974 100644
--- a/src/main/ipc/register.test.ts
+++ b/src/main/ipc/register.test.ts
@@ -227,6 +227,43 @@ describe('registerIpc', () => {
     void deps;
   });
 
+  it('accounts:export returns a string that imports back to the account incl. secret', async () => {
+    const { handlers } = buildHarness();
+    const created = (await handlers.get(CH.accountsCreate)!({
+      label: 'AWS', provider: 'amazon-s3', region: 'eu-central-1', accessKeyId: 'AK', secretAccessKey: 'SECRET',
+    })) as { ok: true; data: { id: string } };
+    const res = (await handlers.get(CH.accountsExport)!({ accountIds: [created.data.id] })) as { ok: boolean; data: string };
+    expect(res.ok).toBe(true);
+    const { importAccounts } = await import('../accounts/accountTransfer');
+    expect(importAccounts(res.data)).toEqual([
+      { label: 'AWS', provider: 'amazon-s3', region: 'eu-central-1', accessKeyId: 'AK', secretAccessKey: 'SECRET', endpoint: undefined, forcePathStyle: false },
+    ]);
+  });
+
+  it('accounts:import creates the accounts and their secrets', async () => {
+    const { exportAccounts } = await import('../accounts/accountTransfer');
+    const blob = exportAccounts([
+      { label: 'Imported', provider: 'amazon-s3', region: 'us-east-1', accessKeyId: 'IK', secretAccessKey: 'IS' },
+    ]);
+    const { handlers, deps } = buildHarness();
+    const res = (await handlers.get(CH.accountsImport)!({ blob })) as { ok: boolean; data: { id: string }[] };
+    expect(res.ok).toBe(true);
+    expect(res.data).toHaveLength(1);
+    expect(deps.accounts.list().map((a) => a.label)).toContain('Imported');
+    expect(deps.secrets.get(res.data[0].id)).toBe('IS');
+  });
+
+  it('accounts:import rejects an unknown provider without creating anything', async () => {
+    const { exportAccounts } = await import('../accounts/accountTransfer');
+    const blob = exportAccounts([
+      { label: 'Bad', provider: 'not-a-provider' as never, region: 'x', accessKeyId: 'K', secretAccessKey: 'S' },
+    ]);
+    const { handlers, deps } = buildHarness();
+    const res = (await handlers.get(CH.accountsImport)!({ blob })) as { ok: boolean };
+    expect(res.ok).toBe(false);
+    expect(deps.accounts.list()).toHaveLength(0);
+  });
+
   it('accounts:create rejects an unknown provider and persists nothing', async () => {
     const { handlers, deps } = buildHarness();
     const res = (await handlers.get(CH.accountsCreate)!({
diff --git a/src/main/ipc/register.ts b/src/main/ipc/register.ts
index 319e760..f1359a2 100644
--- a/src/main/ipc/register.ts
+++ b/src/main/ipc/register.ts
@@ -27,6 +27,8 @@ import type { ObjectAcl } from '../s3/objectAcl';
 import { getEditableMetadata, updateObjectMetadata } from '../s3/objectMetadata';
 import { createFolder, moveObject, moveFolder } from '../s3/transfer';
 import { createBucket } from '../s3/buckets';
+import { exportAccounts, importAccounts, TransferError } from '../accounts/accountTransfer';
+import type { ExportAccount } from '../accounts/accountTransfer';
 import { checkForUpdate } from '../update/checkForUpdate';
 import { planSync, runSync, type Endpoint } from '../s3/sync';
 import { planLocalSync, runLocalSync } from '../s3/localSync';
@@ -201,6 +203,63 @@ export function registerIpc(ipcMain: IpcMainLike, deps: RegisterDeps): void {
     return r.ok ? ok(true as const) : err(r.error.code, r.error.message);
   });
 
+  h(CH.accountsExport, (a: { accountIds: string[]; password?: string }) => {
+    const accounts: ExportAccount[] = [];
+    for (const id of a.accountIds) {
+      const acc = deps.accounts.get(id);
+      if (!acc) continue;
+      const secret = deps.secrets.get(id);
+      if (secret === undefined) {
+        return err('SecretUnavailable', `Cannot read the secret for account "${acc.label}".`);
+      }
+      accounts.push({
+        label: acc.label,
+        provider: acc.provider,
+        region: acc.region,
+        accessKeyId: acc.accessKeyId,
+        secretAccessKey: secret,
+        endpoint: acc.endpoint,
+        forcePathStyle: acc.forcePathStyle,
+      });
+    }
+    if (accounts.length === 0) return err('NothingToExport', 'No accounts to export.');
+    return ok(exportAccounts(accounts, a.password));
+  });
+
+  h(CH.accountsImport, (a: { blob: string; password?: string }) => {
+    let parsed: ExportAccount[];
+    try {
+      parsed = importAccounts(a.blob, a.password);
+    } catch (e) {
+      if (e instanceof TransferError) return err(e.code, e.message);
+      throw e;
+    }
+    const resolved: { acc: ExportAccount; params: ConnParams }[] = [];
+    for (const acc of parsed) {
+      if (!isKnownProvider(acc.provider)) {
+        return err('InvalidProvider', `Unknown provider: ${acc.provider}`);
+      }
+      const params = resolveConnParams(acc);
+      if (!params.ok) return params;
+      resolved.push({ acc, params: params.data });
+    }
+    const created = deps.db.transaction(() => {
+      return resolved.map(({ acc, params }) => {
+        const a2 = deps.accounts.create({
+          label: acc.label,
+          provider: acc.provider,
+          endpoint: params.endpoint,
+          region: acc.region,
+          accessKeyId: acc.accessKeyId,
+          forcePathStyle: params.forcePathStyle,
+        });
+        deps.secrets.set(a2.id, acc.secretAccessKey);
+        return a2;
+      });
+    })();
+    return ok(created);
+  });
+
   h(CH.listBuckets, (accountId: string) => listBuckets(clientFor(accountId)));
 
   h(CH.createBucket, (a: { accountId: string; bucket: string; objectLock: boolean; versioning: boolean }) => {
diff --git a/src/preload.ts b/src/preload.ts
index 0fb9777..ace584f 100644
--- a/src/preload.ts
+++ b/src/preload.ts
@@ -15,6 +15,8 @@ const api = {
     update: (input: ApiMap[typeof CH.accountsUpdate]['args'][0]) => invoke(CH.accountsUpdate, input),
     remove: (id: string) => invoke(CH.accountsRemove, id),
     test: (input: ApiMap[typeof CH.accountsTest]['args'][0]) => invoke(CH.accountsTest, input),
+    export: (a: ApiMap[typeof CH.accountsExport]['args'][0]) => invoke(CH.accountsExport, a),
+    import: (a: ApiMap[typeof CH.accountsImport]['args'][0]) => invoke(CH.accountsImport, a),
   },
   encryptionAvailable: () => invoke(CH.encryptionAvailable),
   listBuckets: (accountId: string) => invoke(CH.listBuckets, accountId),

From 520f78a2fc37b6cb3303caa6267314eefe6df671 Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 09:50:32 +0200
Subject: [PATCH 05/24] feat(accounts): add transfer hooks and i18n keys

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../hooks/useAccountTransfer.test.tsx         | 39 +++++++++++++++++++
 src/renderer/hooks/useAccountTransfer.ts      | 19 +++++++++
 src/renderer/i18n/locales/de.json             | 23 ++++++++++-
 src/renderer/i18n/locales/en.json             | 23 ++++++++++-
 src/renderer/i18n/locales/fr.json             | 23 ++++++++++-
 src/renderer/i18n/locales/nl.json             | 23 ++++++++++-
 src/renderer/i18n/locales/pl.json             | 23 ++++++++++-
 src/renderer/i18n/locales/ro.json             | 23 ++++++++++-
 8 files changed, 190 insertions(+), 6 deletions(-)
 create mode 100644 src/renderer/hooks/useAccountTransfer.test.tsx
 create mode 100644 src/renderer/hooks/useAccountTransfer.ts

diff --git a/src/renderer/hooks/useAccountTransfer.test.tsx b/src/renderer/hooks/useAccountTransfer.test.tsx
new file mode 100644
index 0000000..313bf08
--- /dev/null
+++ b/src/renderer/hooks/useAccountTransfer.test.tsx
@@ -0,0 +1,39 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { renderHook, waitFor } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { ReactNode } from 'react';
+import { useExportAccounts, useImportAccounts } from './useAccountTransfer';
+
+function wrapper() {
+  const client = new QueryClient({ defaultOptions: { mutations: { retry: false } } });
+  return ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={client}>{children}</QueryClientProvider>
+  );
+}
+
+beforeEach(() => {
+  (window as unknown as { s3: unknown }).s3 = {
+    accounts: {
+      export: vi.fn().mockResolvedValue({ ok: true, data: 'BLOB' }),
+      import: vi.fn().mockResolvedValue({ ok: true, data: [{ id: 'n1' }] }),
+    },
+  };
+});
+
+describe('useExportAccounts', () => {
+  it('returns the export string', async () => {
+    const { result } = renderHook(() => useExportAccounts(), { wrapper: wrapper() });
+    result.current.mutate({ accountIds: ['a'], password: 'pw' });
+    await waitFor(() => expect(result.current.data).toBe('BLOB'));
+    expect((window.s3 as unknown as { accounts: { export: ReturnType<typeof vi.fn> } }).accounts.export)
+      .toHaveBeenCalledWith({ accountIds: ['a'], password: 'pw' });
+  });
+});
+
+describe('useImportAccounts', () => {
+  it('returns the imported accounts', async () => {
+    const { result } = renderHook(() => useImportAccounts(), { wrapper: wrapper() });
+    result.current.mutate({ blob: 'BLOB' });
+    await waitFor(() => expect(result.current.data).toEqual([{ id: 'n1' }]));
+  });
+});
diff --git a/src/renderer/hooks/useAccountTransfer.ts b/src/renderer/hooks/useAccountTransfer.ts
new file mode 100644
index 0000000..f03108e
--- /dev/null
+++ b/src/renderer/hooks/useAccountTransfer.ts
@@ -0,0 +1,19 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { unwrap } from '../lib/result';
+import { accountsKey } from './useAccounts';
+
+export function useExportAccounts() {
+  return useMutation({
+    mutationFn: async (input: { accountIds: string[]; password?: string }) =>
+      unwrap(await window.s3.accounts.export(input)),
+  });
+}
+
+export function useImportAccounts() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async (input: { blob: string; password?: string }) =>
+      unwrap(await window.s3.accounts.import(input)),
+    onSuccess: () => qc.invalidateQueries({ queryKey: accountsKey }),
+  });
+}
diff --git a/src/renderer/i18n/locales/de.json b/src/renderer/i18n/locales/de.json
index e5dcd9b..8e76694 100644
--- a/src/renderer/i18n/locales/de.json
+++ b/src/renderer/i18n/locales/de.json
@@ -326,7 +326,28 @@
     "moved": "Verschoben",
     "name": "Name",
     "noSubfolders": "Keine Unterordner",
-    "moveHere": "Hierher verschieben"
+    "moveHere": "Hierher verschieben",
+    "exportTitle": "Konten exportieren",
+    "importTitle": "Konten importieren",
+    "password": "Passwort (optional)",
+    "importPassword": "Passwort",
+    "noPasswordWarning": "Ohne Passwort sind die Secret Keys nicht verschlüsselt — halte diesen Export geheim.",
+    "generate": "Export erzeugen",
+    "copy": "Kopieren",
+    "copied": "Kopiert",
+    "download": "Herunterladen",
+    "resultAria": "Export-String",
+    "pastePlaceholder": "Export-String hier einfügen",
+    "pasteAria": "Importdaten",
+    "loadFile": "Datei laden",
+    "import": "Importieren",
+    "passwordRequired": "Dieser Export ist passwortgeschützt. Bitte Passwort eingeben.",
+    "incorrectPassword": "Falsches Passwort.",
+    "invalidData": "Das sieht nicht nach einem gültigen Konten-Export aus.",
+    "imported": "{{count}} Konten importiert",
+    "importAccounts": "Importieren",
+    "exportAll": "Alle exportieren",
+    "exportAria": "{{label}} exportieren"
   },
   "dashboard": {
     "title": "Dashboard",
diff --git a/src/renderer/i18n/locales/en.json b/src/renderer/i18n/locales/en.json
index d772c1b..218952c 100644
--- a/src/renderer/i18n/locales/en.json
+++ b/src/renderer/i18n/locales/en.json
@@ -326,7 +326,28 @@
     "moved": "Moved",
     "name": "Name",
     "noSubfolders": "No subfolders",
-    "moveHere": "Move here"
+    "moveHere": "Move here",
+    "exportTitle": "Export accounts",
+    "importTitle": "Import accounts",
+    "password": "Password (optional)",
+    "importPassword": "Password",
+    "noPasswordWarning": "Without a password the secret keys are not encrypted — keep this export private.",
+    "generate": "Generate export",
+    "copy": "Copy",
+    "copied": "Copied",
+    "download": "Download",
+    "resultAria": "Export string",
+    "pastePlaceholder": "Paste the export string here",
+    "pasteAria": "Import data",
+    "loadFile": "Load file",
+    "import": "Import",
+    "passwordRequired": "This export is password-protected. Enter the password.",
+    "incorrectPassword": "Incorrect password.",
+    "invalidData": "This doesn't look like a valid account export.",
+    "imported": "Imported {{count}} accounts",
+    "importAccounts": "Import",
+    "exportAll": "Export all",
+    "exportAria": "Export {{label}}"
   },
   "dashboard": {
     "title": "Dashboard",
diff --git a/src/renderer/i18n/locales/fr.json b/src/renderer/i18n/locales/fr.json
index c55b92c..c580a34 100644
--- a/src/renderer/i18n/locales/fr.json
+++ b/src/renderer/i18n/locales/fr.json
@@ -326,7 +326,28 @@
     "moved": "Déplacé",
     "name": "Nom",
     "noSubfolders": "Aucun sous-dossier",
-    "moveHere": "Déplacer ici"
+    "moveHere": "Déplacer ici",
+    "exportTitle": "Exporter les comptes",
+    "importTitle": "Importer des comptes",
+    "password": "Mot de passe (optionnel)",
+    "importPassword": "Mot de passe",
+    "noPasswordWarning": "Sans mot de passe, les clés secrètes ne sont pas chiffrées — gardez cet export privé.",
+    "generate": "Générer l'export",
+    "copy": "Copier",
+    "copied": "Copié",
+    "download": "Télécharger",
+    "resultAria": "Chaîne d'export",
+    "pastePlaceholder": "Collez la chaîne d'export ici",
+    "pasteAria": "Données d'import",
+    "loadFile": "Charger un fichier",
+    "import": "Importer",
+    "passwordRequired": "Cet export est protégé par mot de passe. Saisissez le mot de passe.",
+    "incorrectPassword": "Mot de passe incorrect.",
+    "invalidData": "Cela ne ressemble pas à un export de comptes valide.",
+    "imported": "{{count}} comptes importés",
+    "importAccounts": "Importer",
+    "exportAll": "Tout exporter",
+    "exportAria": "Exporter {{label}}"
   },
   "dashboard": {
     "title": "Tableau de bord",
diff --git a/src/renderer/i18n/locales/nl.json b/src/renderer/i18n/locales/nl.json
index 3263cfd..f2d1a95 100644
--- a/src/renderer/i18n/locales/nl.json
+++ b/src/renderer/i18n/locales/nl.json
@@ -326,7 +326,28 @@
     "moved": "Verplaatst",
     "name": "Naam",
     "noSubfolders": "Geen submappen",
-    "moveHere": "Hierheen verplaatsen"
+    "moveHere": "Hierheen verplaatsen",
+    "exportTitle": "Accounts exporteren",
+    "importTitle": "Accounts importeren",
+    "password": "Wachtwoord (optioneel)",
+    "importPassword": "Wachtwoord",
+    "noPasswordWarning": "Zonder wachtwoord zijn de secret keys niet versleuteld — houd deze export privé.",
+    "generate": "Export genereren",
+    "copy": "Kopiëren",
+    "copied": "Gekopieerd",
+    "download": "Downloaden",
+    "resultAria": "Exportreeks",
+    "pastePlaceholder": "Plak hier de exportreeks",
+    "pasteAria": "Importgegevens",
+    "loadFile": "Bestand laden",
+    "import": "Importeren",
+    "passwordRequired": "Deze export is met een wachtwoord beveiligd. Voer het wachtwoord in.",
+    "incorrectPassword": "Onjuist wachtwoord.",
+    "invalidData": "Dit lijkt geen geldige accountexport.",
+    "imported": "{{count}} accounts geïmporteerd",
+    "importAccounts": "Importeren",
+    "exportAll": "Alles exporteren",
+    "exportAria": "{{label}} exporteren"
   },
   "dashboard": {
     "title": "Dashboard",
diff --git a/src/renderer/i18n/locales/pl.json b/src/renderer/i18n/locales/pl.json
index 8ed5f5e..0a91081 100644
--- a/src/renderer/i18n/locales/pl.json
+++ b/src/renderer/i18n/locales/pl.json
@@ -330,7 +330,28 @@
     "moved": "Przeniesiono",
     "name": "Nazwa",
     "noSubfolders": "Brak podfolderów",
-    "moveHere": "Przenieś tutaj"
+    "moveHere": "Przenieś tutaj",
+    "exportTitle": "Eksportuj konta",
+    "importTitle": "Importuj konta",
+    "password": "Hasło (opcjonalne)",
+    "importPassword": "Hasło",
+    "noPasswordWarning": "Bez hasła klucze tajne nie są szyfrowane — zachowaj ten eksport prywatnie.",
+    "generate": "Wygeneruj eksport",
+    "copy": "Kopiuj",
+    "copied": "Skopiowano",
+    "download": "Pobierz",
+    "resultAria": "Ciąg eksportu",
+    "pastePlaceholder": "Wklej tutaj ciąg eksportu",
+    "pasteAria": "Dane importu",
+    "loadFile": "Wczytaj plik",
+    "import": "Importuj",
+    "passwordRequired": "Ten eksport jest chroniony hasłem. Wprowadź hasło.",
+    "incorrectPassword": "Nieprawidłowe hasło.",
+    "invalidData": "To nie wygląda na prawidłowy eksport kont.",
+    "imported": "Zaimportowano {{count}} kont",
+    "importAccounts": "Importuj",
+    "exportAll": "Eksportuj wszystkie",
+    "exportAria": "Eksportuj {{label}}"
   },
   "dashboard": {
     "title": "Pulpit",
diff --git a/src/renderer/i18n/locales/ro.json b/src/renderer/i18n/locales/ro.json
index b0fd945..3ac13f9 100644
--- a/src/renderer/i18n/locales/ro.json
+++ b/src/renderer/i18n/locales/ro.json
@@ -328,7 +328,28 @@
     "moved": "Mutat",
     "name": "Nume",
     "noSubfolders": "Niciun subfolder",
-    "moveHere": "Mută aici"
+    "moveHere": "Mută aici",
+    "exportTitle": "Exportă conturile",
+    "importTitle": "Importă conturi",
+    "password": "Parolă (opțional)",
+    "importPassword": "Parolă",
+    "noPasswordWarning": "Fără parolă, cheile secrete nu sunt criptate — păstrează acest export privat.",
+    "generate": "Generează exportul",
+    "copy": "Copiază",
+    "copied": "Copiat",
+    "download": "Descarcă",
+    "resultAria": "Șir de export",
+    "pastePlaceholder": "Lipește aici șirul de export",
+    "pasteAria": "Date de import",
+    "loadFile": "Încarcă fișier",
+    "import": "Importă",
+    "passwordRequired": "Acest export este protejat cu parolă. Introdu parola.",
+    "incorrectPassword": "Parolă incorectă.",
+    "invalidData": "Acesta nu pare un export de conturi valid.",
+    "imported": "{{count}} conturi importate",
+    "importAccounts": "Importă",
+    "exportAll": "Exportă tot",
+    "exportAria": "Exportă {{label}}"
   },
   "dashboard": {
     "title": "Tablou de bord",

From f73d38cb0e83ba7d3878850e171f1f2d08957ce3 Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 09:58:41 +0200
Subject: [PATCH 06/24] feat(accounts): add export dialog

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../accounts/ExportAccountsDialog.test.tsx    | 50 +++++++++++
 .../accounts/ExportAccountsDialog.tsx         | 86 +++++++++++++++++++
 2 files changed, 136 insertions(+)
 create mode 100644 src/renderer/components/accounts/ExportAccountsDialog.test.tsx
 create mode 100644 src/renderer/components/accounts/ExportAccountsDialog.tsx

diff --git a/src/renderer/components/accounts/ExportAccountsDialog.test.tsx b/src/renderer/components/accounts/ExportAccountsDialog.test.tsx
new file mode 100644
index 0000000..a12ec92
--- /dev/null
+++ b/src/renderer/components/accounts/ExportAccountsDialog.test.tsx
@@ -0,0 +1,50 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { ReactNode } from 'react';
+import { ToastProvider } from '../ui/ToastProvider';
+import { ExportAccountsDialog } from './ExportAccountsDialog';
+
+function wrap(node: ReactNode) {
+  const client = new QueryClient({ defaultOptions: { mutations: { retry: false } } });
+  return render(
+    <QueryClientProvider client={client}>
+      <ToastProvider>{node}</ToastProvider>
+    </QueryClientProvider>,
+  );
+}
+
+beforeEach(() => {
+  Object.assign(navigator, { clipboard: { writeText: vi.fn().mockResolvedValue(undefined) } });
+  (window as unknown as { s3: unknown }).s3 = {
+    accounts: { export: vi.fn().mockResolvedValue({ ok: true, data: 'EXPORT-BLOB' }) },
+    saveTextFile: vi.fn().mockResolvedValue({ ok: true, data: { saved: true } }),
+  };
+});
+
+describe('ExportAccountsDialog', () => {
+  it('warns when no password is set and generates the export string', async () => {
+    wrap(<ExportAccountsDialog accountIds={['a']} onClose={() => {}} />);
+    expect(screen.getByText(/secret keys are not encrypted/i)).toBeInTheDocument();
+    await userEvent.click(screen.getByRole('button', { name: 'Generate export' }));
+    const out = await screen.findByLabelText('Export string');
+    expect(out).toHaveValue('EXPORT-BLOB');
+  });
+
+  it('downloads the generated string via saveTextFile', async () => {
+    wrap(<ExportAccountsDialog accountIds={['a']} onClose={() => {}} />);
+    await userEvent.click(screen.getByRole('button', { name: 'Generate export' }));
+    await screen.findByLabelText('Export string');
+    await userEvent.click(screen.getByRole('button', { name: 'Download' }));
+    await waitFor(() =>
+      expect(window.s3.saveTextFile).toHaveBeenCalledWith({ defaultName: 's3manager-accounts.txt', contents: 'EXPORT-BLOB' }),
+    );
+  });
+
+  it('hides the warning once a password is entered', async () => {
+    wrap(<ExportAccountsDialog accountIds={['a']} onClose={() => {}} />);
+    await userEvent.type(screen.getByLabelText('Password (optional)'), 'pw');
+    expect(screen.queryByText(/secret keys are not encrypted/i)).not.toBeInTheDocument();
+  });
+});
diff --git a/src/renderer/components/accounts/ExportAccountsDialog.tsx b/src/renderer/components/accounts/ExportAccountsDialog.tsx
new file mode 100644
index 0000000..09b9517
--- /dev/null
+++ b/src/renderer/components/accounts/ExportAccountsDialog.tsx
@@ -0,0 +1,86 @@
+import { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { FiX } from 'react-icons/fi';
+import { useExportAccounts } from '../../hooks/useAccountTransfer';
+import { useToast } from '../ui/ToastProvider';
+
+export function ExportAccountsDialog({ accountIds, onClose }: { accountIds: string[]; onClose: () => void }) {
+  const { t } = useTranslation();
+  const { show } = useToast();
+  const exportAccounts = useExportAccounts();
+  const [password, setPassword] = useState('');
+  const [result, setResult] = useState<string | null>(null);
+
+  const onGenerate = async () => {
+    try {
+      const blob = await exportAccounts.mutateAsync({ accountIds, password: password || undefined });
+      setResult(blob);
+    } catch (e) {
+      show((e as Error).message, 'error');
+    }
+  };
+
+  const onCopy = async () => {
+    if (result === null) return;
+    await navigator.clipboard.writeText(result);
+    show(t('transfer.copied'));
+  };
+
+  const onDownload = async () => {
+    if (result === null) return;
+    await window.s3.saveTextFile({ defaultName: 's3manager-accounts.txt', contents: result });
+  };
+
+  const field = 'mt-1 w-full rounded border border-slate-300 px-2 py-1 text-sm dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100';
+
+  return (
+    <div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">
+      <div className="w-[28rem] max-w-[90vw] rounded bg-white p-4 shadow-lg dark:bg-slate-900">
+        <div className="flex items-center justify-between pb-2">
+          <p className="text-sm font-medium text-slate-800 dark:text-slate-100">{t('transfer.exportTitle')}</p>
+          <button type="button" aria-label={t('common.close')} className="rounded px-2 hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onClose}>
+            <FiX className="h-4 w-4" aria-hidden />
+          </button>
+        </div>
+
+        <label className="block text-sm">
+          {t('transfer.password')}
+          <input type="password" className={field} value={password} onChange={(e) => setPassword(e.target.value)} />
+        </label>
+        {password.length === 0 && (
+          <p className="mt-2 text-xs text-amber-600 dark:text-amber-400">{t('transfer.noPasswordWarning')}</p>
+        )}
+
+        {result === null ? (
+          <div className="mt-4 flex justify-end">
+            <button
+              type="button"
+              disabled={exportAccounts.isPending}
+              className="rounded bg-slate-800 px-3 py-1 text-sm text-white hover:bg-slate-700 disabled:opacity-40 dark:bg-slate-200 dark:text-slate-900"
+              onClick={onGenerate}
+            >
+              {t('transfer.generate')}
+            </button>
+          </div>
+        ) : (
+          <>
+            <textarea
+              aria-label={t('transfer.resultAria')}
+              readOnly
+              value={result}
+              className="mt-3 h-28 w-full resize-none rounded border border-slate-300 p-2 font-mono text-xs dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100"
+            />
+            <div className="mt-3 flex justify-end gap-2">
+              <button type="button" className="rounded border border-slate-300 px-3 py-1 text-sm hover:bg-slate-50 dark:border-slate-700 dark:hover:bg-slate-800" onClick={onCopy}>
+                {t('transfer.copy')}
+              </button>
+              <button type="button" className="rounded border border-slate-300 px-3 py-1 text-sm hover:bg-slate-50 dark:border-slate-700 dark:hover:bg-slate-800" onClick={onDownload}>
+                {t('transfer.download')}
+              </button>
+            </div>
+          </>
+        )}
+      </div>
+    </div>
+  );
+}

From 893e72296bb28b00e02a3ed27a5ed5c07c283cbd Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 10:01:52 +0200
Subject: [PATCH 07/24] test(accounts): cover export error toast

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../components/accounts/ExportAccountsDialog.test.tsx    | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/renderer/components/accounts/ExportAccountsDialog.test.tsx b/src/renderer/components/accounts/ExportAccountsDialog.test.tsx
index a12ec92..964b655 100644
--- a/src/renderer/components/accounts/ExportAccountsDialog.test.tsx
+++ b/src/renderer/components/accounts/ExportAccountsDialog.test.tsx
@@ -47,4 +47,13 @@ describe('ExportAccountsDialog', () => {
     await userEvent.type(screen.getByLabelText('Password (optional)'), 'pw');
     expect(screen.queryByText(/secret keys are not encrypted/i)).not.toBeInTheDocument();
   });
+
+  it('toasts an error when generation fails', async () => {
+    (window.s3 as unknown as { accounts: { export: ReturnType<typeof vi.fn> } }).accounts.export = vi
+      .fn()
+      .mockResolvedValue({ ok: false, error: { code: 'SecretUnavailable', message: 'Cannot read the secret.' } });
+    wrap(<ExportAccountsDialog accountIds={['a']} onClose={() => {}} />);
+    await userEvent.click(screen.getByRole('button', { name: 'Generate export' }));
+    expect(await screen.findByText(/Cannot read the secret\./)).toBeInTheDocument();
+  });
 });

From 33a244aedb14b3d7c233c200106150d0bc727b14 Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 10:04:58 +0200
Subject: [PATCH 08/24] feat(accounts): add import dialog

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../accounts/ImportAccountsDialog.test.tsx    | 54 ++++++++++++
 .../accounts/ImportAccountsDialog.tsx         | 82 +++++++++++++++++++
 2 files changed, 136 insertions(+)
 create mode 100644 src/renderer/components/accounts/ImportAccountsDialog.test.tsx
 create mode 100644 src/renderer/components/accounts/ImportAccountsDialog.tsx

diff --git a/src/renderer/components/accounts/ImportAccountsDialog.test.tsx b/src/renderer/components/accounts/ImportAccountsDialog.test.tsx
new file mode 100644
index 0000000..896a4f9
--- /dev/null
+++ b/src/renderer/components/accounts/ImportAccountsDialog.test.tsx
@@ -0,0 +1,54 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { ReactNode } from 'react';
+import { ToastProvider } from '../ui/ToastProvider';
+import { ImportAccountsDialog } from './ImportAccountsDialog';
+
+function wrap(node: ReactNode) {
+  const client = new QueryClient({ defaultOptions: { mutations: { retry: false } } });
+  return render(
+    <QueryClientProvider client={client}>
+      <ToastProvider>{node}</ToastProvider>
+    </QueryClientProvider>,
+  );
+}
+
+beforeEach(() => {
+  (window as unknown as { s3: unknown }).s3 = {
+    accounts: { import: vi.fn().mockResolvedValue({ ok: true, data: [{ id: 'n1' }, { id: 'n2' }] }) },
+    openTextFile: vi.fn().mockResolvedValue({ ok: true, data: 'FILE-BLOB' }),
+  };
+});
+
+describe('ImportAccountsDialog', () => {
+  it('imports a pasted blob and reports the count', async () => {
+    const onImported = vi.fn();
+    const onClose = vi.fn();
+    wrap(<ImportAccountsDialog onClose={onClose} onImported={onImported} />);
+    await userEvent.type(screen.getByLabelText('Import data'), 'BLOB');
+    await userEvent.click(screen.getByRole('button', { name: 'Import' }));
+    await waitFor(() => expect(onImported).toHaveBeenCalled());
+    expect(window.s3.accounts.import).toHaveBeenCalledWith({ blob: 'BLOB', password: undefined });
+    expect(onClose).toHaveBeenCalled();
+  });
+
+  it('loads a file into the textarea', async () => {
+    wrap(<ImportAccountsDialog onClose={() => {}} onImported={() => {}} />);
+    await userEvent.click(screen.getByRole('button', { name: 'Load file' }));
+    await waitFor(() => expect(screen.getByLabelText('Import data')).toHaveValue('FILE-BLOB'));
+  });
+
+  it('shows an inline error and stays open on an incorrect password', async () => {
+    (window.s3 as unknown as { accounts: { import: ReturnType<typeof vi.fn> } }).accounts.import = vi
+      .fn()
+      .mockResolvedValue({ ok: false, error: { code: 'IncorrectPassword', message: 'Incorrect password.' } });
+    const onClose = vi.fn();
+    wrap(<ImportAccountsDialog onClose={onClose} onImported={() => {}} />);
+    await userEvent.type(screen.getByLabelText('Import data'), 'BLOB');
+    await userEvent.click(screen.getByRole('button', { name: 'Import' }));
+    expect(await screen.findByText('Incorrect password.')).toBeInTheDocument();
+    expect(onClose).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/renderer/components/accounts/ImportAccountsDialog.tsx b/src/renderer/components/accounts/ImportAccountsDialog.tsx
new file mode 100644
index 0000000..7353d27
--- /dev/null
+++ b/src/renderer/components/accounts/ImportAccountsDialog.tsx
@@ -0,0 +1,82 @@
+import { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { FiX } from 'react-icons/fi';
+import { useImportAccounts } from '../../hooks/useAccountTransfer';
+import { useToast } from '../ui/ToastProvider';
+
+export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => void; onImported: () => void }) {
+  const { t } = useTranslation();
+  const { show } = useToast();
+  const importAccounts = useImportAccounts();
+  const [blob, setBlob] = useState('');
+  const [password, setPassword] = useState('');
+  const [error, setError] = useState<string | null>(null);
+
+  const onLoadFile = async () => {
+    const text = await window.s3.openTextFile();
+    if (text.ok && text.data !== null) setBlob(text.data);
+  };
+
+  const onImport = async () => {
+    setError(null);
+    try {
+      const created = await importAccounts.mutateAsync({ blob, password: password || undefined });
+      show(t('transfer.imported', { count: created.length }));
+      onImported();
+      onClose();
+    } catch (e) {
+      const msg = (e as Error).message;
+      // unwrap() prepends "code: " – strip it so only the human message is shown
+      setError(msg.includes(': ') ? msg.split(': ').slice(1).join(': ') : msg);
+    }
+  };
+
+  const field = 'mt-1 w-full rounded border border-slate-300 px-2 py-1 text-sm dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100';
+
+  return (
+    <div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">
+      <div className="w-[28rem] max-w-[90vw] rounded bg-white p-4 shadow-lg dark:bg-slate-900">
+        <div className="flex items-center justify-between pb-2">
+          <p className="text-sm font-medium text-slate-800 dark:text-slate-100">{t('transfer.importTitle')}</p>
+          <button type="button" aria-label={t('common.close')} className="rounded px-2 hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onClose}>
+            <FiX className="h-4 w-4" aria-hidden />
+          </button>
+        </div>
+
+        <textarea
+          aria-label={t('transfer.pasteAria')}
+          placeholder={t('transfer.pastePlaceholder')}
+          value={blob}
+          onChange={(e) => setBlob(e.target.value)}
+          className="h-28 w-full resize-none rounded border border-slate-300 p-2 font-mono text-xs dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100"
+        />
+        <div className="mt-2">
+          <button type="button" className="rounded border border-slate-300 px-3 py-1 text-sm hover:bg-slate-50 dark:border-slate-700 dark:hover:bg-slate-800" onClick={onLoadFile}>
+            {t('transfer.loadFile')}
+          </button>
+        </div>
+
+        <label className="mt-3 block text-sm">
+          {t('transfer.importPassword')}
+          <input type="password" className={field} value={password} onChange={(e) => setPassword(e.target.value)} />
+        </label>
+
+        {error !== null && <p className="mt-2 text-xs text-red-600 dark:text-red-400">{error}</p>}
+
+        <div className="mt-4 flex justify-end gap-2">
+          <button type="button" className="rounded px-3 py-1 text-sm hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onClose}>
+            {t('common.cancel')}
+          </button>
+          <button
+            type="button"
+            disabled={blob.trim().length === 0 || importAccounts.isPending}
+            className="rounded bg-slate-800 px-3 py-1 text-sm text-white hover:bg-slate-700 disabled:opacity-40 dark:bg-slate-200 dark:text-slate-900"
+            onClick={onImport}
+          >
+            {t('transfer.import')}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

From 4f6c347dd9b8c1d1eee61495b1b51bf664875241 Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 10:09:03 +0200
Subject: [PATCH 09/24] refactor(ui): extract humanErrorMessage helper for
 inline errors

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../accounts/ImportAccountsDialog.tsx         |  5 ++---
 src/renderer/lib/result.test.ts               | 20 ++++++++++++++++++-
 src/renderer/lib/result.ts                    |  8 ++++++++
 3 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/src/renderer/components/accounts/ImportAccountsDialog.tsx b/src/renderer/components/accounts/ImportAccountsDialog.tsx
index 7353d27..3db6708 100644
--- a/src/renderer/components/accounts/ImportAccountsDialog.tsx
+++ b/src/renderer/components/accounts/ImportAccountsDialog.tsx
@@ -3,6 +3,7 @@ import { useTranslation } from 'react-i18next';
 import { FiX } from 'react-icons/fi';
 import { useImportAccounts } from '../../hooks/useAccountTransfer';
 import { useToast } from '../ui/ToastProvider';
+import { humanErrorMessage } from '../../lib/result';
 
 export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => void; onImported: () => void }) {
   const { t } = useTranslation();
@@ -25,9 +26,7 @@ export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => v
       onImported();
       onClose();
     } catch (e) {
-      const msg = (e as Error).message;
-      // unwrap() prepends "code: " – strip it so only the human message is shown
-      setError(msg.includes(': ') ? msg.split(': ').slice(1).join(': ') : msg);
+      setError(humanErrorMessage(e));
     }
   };
 
diff --git a/src/renderer/lib/result.test.ts b/src/renderer/lib/result.test.ts
index cde2a7c..c8e7296 100644
--- a/src/renderer/lib/result.test.ts
+++ b/src/renderer/lib/result.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { unwrap } from './result';
+import { unwrap, humanErrorMessage } from './result';
 
 describe('unwrap', () => {
   it('returns data for an ok Result', () => {
@@ -12,3 +12,21 @@ describe('unwrap', () => {
     );
   });
 });
+
+describe('humanErrorMessage', () => {
+  it('strips the leading "Code: " prefix that unwrap adds', () => {
+    expect(humanErrorMessage(new Error('IncorrectPassword: Incorrect password.'))).toBe('Incorrect password.');
+  });
+
+  it('preserves colons within the message body', () => {
+    expect(humanErrorMessage(new Error('Code: a: b: c'))).toBe('a: b: c');
+  });
+
+  it('returns a message without a prefix unchanged', () => {
+    expect(humanErrorMessage(new Error('plain message'))).toBe('plain message');
+  });
+
+  it('handles non-Error values', () => {
+    expect(humanErrorMessage('boom')).toBe('boom');
+  });
+});
diff --git a/src/renderer/lib/result.ts b/src/renderer/lib/result.ts
index a5c4fa7..ac6ac60 100644
--- a/src/renderer/lib/result.ts
+++ b/src/renderer/lib/result.ts
@@ -8,3 +8,11 @@ export function unwrap<T>(result: Result<T>): T {
   if (result.ok) return result.data;
   throw new Error(`${result.error.code}: ${result.error.message}`);
 }
+
+/** Strip the leading "Code: " that {@link unwrap} prepends, leaving the human
+ *  message — for inline error display. Returns the input unchanged if it has no
+ *  prefix, and preserves any colons within the message body. */
+export function humanErrorMessage(error: unknown): string {
+  const msg = error instanceof Error ? error.message : String(error);
+  return msg.includes(': ') ? msg.split(': ').slice(1).join(': ') : msg;
+}

From 1fb2f41f98ce4a94a41922bdee73aa94012010c0 Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 10:12:31 +0200
Subject: [PATCH 10/24] feat(accounts): export/import entry points in the
 Accounts screen

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../connections/ConnectionsScreen.test.tsx    | 26 +++++++++
 .../connections/ConnectionsScreen.tsx         | 53 ++++++++++++++++---
 2 files changed, 71 insertions(+), 8 deletions(-)

diff --git a/src/renderer/components/connections/ConnectionsScreen.test.tsx b/src/renderer/components/connections/ConnectionsScreen.test.tsx
index 364fa2a..8070776 100644
--- a/src/renderer/components/connections/ConnectionsScreen.test.tsx
+++ b/src/renderer/components/connections/ConnectionsScreen.test.tsx
@@ -87,4 +87,30 @@ describe('ConnectionsScreen', () => {
     wrap(<ConnectionsScreen />);
     expect(await screen.findByText('No accounts yet')).toBeInTheDocument();
   });
+
+  it('opens the export dialog from a row export button', async () => {
+    wrap(<ConnectionsScreen />);
+    await userEvent.click(await screen.findByRole('button', { name: 'Export AWS prod' }));
+    expect(screen.getByText('Export accounts', { selector: 'p' })).toBeInTheDocument();
+  });
+
+  it('opens the import dialog from the header', async () => {
+    wrap(<ConnectionsScreen />);
+    await userEvent.click(await screen.findByRole('button', { name: 'Import' }));
+    expect(screen.getByText('Import accounts', { selector: 'p' })).toBeInTheDocument();
+  });
+
+  it('opens the export-all dialog from the header', async () => {
+    wrap(<ConnectionsScreen />);
+    await userEvent.click(await screen.findByRole('button', { name: 'Export all' }));
+    expect(screen.getByText('Export accounts', { selector: 'p' })).toBeInTheDocument();
+  });
+
+  it('disables export-all when there are no accounts', async () => {
+    (window.s3 as unknown as { accounts: { list: ReturnType<typeof vi.fn> } }).accounts.list = vi
+      .fn()
+      .mockResolvedValue({ ok: true, data: [] });
+    wrap(<ConnectionsScreen />);
+    await waitFor(() => expect(screen.getByRole('button', { name: 'Export all' })).toBeDisabled());
+  });
 });
diff --git a/src/renderer/components/connections/ConnectionsScreen.tsx b/src/renderer/components/connections/ConnectionsScreen.tsx
index fd12406..f2d5410 100644
--- a/src/renderer/components/connections/ConnectionsScreen.tsx
+++ b/src/renderer/components/connections/ConnectionsScreen.tsx
@@ -1,10 +1,12 @@
 import { useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { FiTrash2, FiEdit2 } from 'react-icons/fi';
+import { FiTrash2, FiEdit2, FiUpload } from 'react-icons/fi';
 import { useAccounts, useCreateAccount, useUpdateAccount, useRemoveAccount } from '../../hooks/useAccounts';
 import { ProviderBadge } from '../accounts/ProviderBadge';
 import { AccountForm } from '../accounts/AccountForm';
 import type { Account } from '../../../main/storage/accountsRepo';
+import { ExportAccountsDialog } from '../accounts/ExportAccountsDialog';
+import { ImportAccountsDialog } from '../accounts/ImportAccountsDialog';
 
 // null = list view; 'new' = add form; Account = edit form for that account
 type Editing = null | 'new' | Account;
@@ -17,18 +19,38 @@ export function ConnectionsScreen({ onAccountRemoved }: { onAccountRemoved?: (id
   const removeAccount = useRemoveAccount();
   const [editing, setEditing] = useState<Editing>(null);
 
+  // null = closed; export those ids; or the import dialog
+  const [transfer, setTransfer] = useState<null | { kind: 'export'; ids: string[] } | { kind: 'import' }>(null);
+
   return (
     <div className="h-full overflow-auto p-6">
       <div className="flex items-center justify-between pb-3">
         <h2 className="text-lg font-semibold">{t('connections.title')}</h2>
         {editing === null && (
-          <button
-            type="button"
-            className="rounded border border-slate-300 dark:border-slate-700 px-3 py-1 text-sm hover:bg-slate-50 dark:hover:bg-slate-800"
-            onClick={() => setEditing('new')}
-          >
-            {t('connections.addAccount')}
-          </button>
+          <div className="flex items-center gap-2">
+            <button
+              type="button"
+              className="rounded border border-slate-300 dark:border-slate-700 px-3 py-1 text-sm hover:bg-slate-50 dark:hover:bg-slate-800"
+              onClick={() => setTransfer({ kind: 'import' })}
+            >
+              {t('transfer.importAccounts')}
+            </button>
+            <button
+              type="button"
+              disabled={!accounts.data || accounts.data.length === 0}
+              className="rounded border border-slate-300 dark:border-slate-700 px-3 py-1 text-sm hover:bg-slate-50 dark:hover:bg-slate-800 disabled:opacity-40"
+              onClick={() => setTransfer({ kind: 'export', ids: (accounts.data ?? []).map((a) => a.id) })}
+            >
+              {t('transfer.exportAll')}
+            </button>
+            <button
+              type="button"
+              className="rounded border border-slate-300 dark:border-slate-700 px-3 py-1 text-sm hover:bg-slate-50 dark:hover:bg-slate-800"
+              onClick={() => setEditing('new')}
+            >
+              {t('connections.addAccount')}
+            </button>
+          </div>
         )}
       </div>
 
@@ -68,6 +90,14 @@ export function ConnectionsScreen({ onAccountRemoved }: { onAccountRemoved?: (id
                   <ProviderBadge provider={acc.provider} />
                 </span>
                 <div className="flex items-center gap-1">
+                  <button
+                    type="button"
+                    aria-label={t('transfer.exportAria', { label: acc.label })}
+                    className="rounded px-1 text-slate-400 dark:text-slate-500 hover:bg-slate-100 dark:hover:bg-slate-800 hover:text-slate-700 dark:hover:text-slate-200"
+                    onClick={() => setTransfer({ kind: 'export', ids: [acc.id] })}
+                  >
+                    <FiUpload className="h-4 w-4" aria-hidden />
+                  </button>
                   <button
                     type="button"
                     aria-label={t('connections.editAria', { label: acc.label })}
@@ -94,6 +124,13 @@ export function ConnectionsScreen({ onAccountRemoved }: { onAccountRemoved?: (id
           </ul>
         </>
       )}
+
+      {transfer?.kind === 'export' && (
+        <ExportAccountsDialog accountIds={transfer.ids} onClose={() => setTransfer(null)} />
+      )}
+      {transfer?.kind === 'import' && (
+        <ImportAccountsDialog onClose={() => setTransfer(null)} onImported={() => undefined} />
+      )}
     </div>
   );
 }

From 4aca8abbd93831536dbebe9228ce6cc0421b08e9 Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 10:17:16 +0200
Subject: [PATCH 11/24] fix(accounts): localize import error messages

Map TransferError codes to the existing transfer.* i18n keys so import errors are shown in the user's language instead of raw English.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../components/accounts/ImportAccountsDialog.tsx     | 12 ++++++++++--
 src/renderer/lib/result.test.ts                      | 12 +++++++++++-
 src/renderer/lib/result.ts                           |  8 ++++++++
 3 files changed, 29 insertions(+), 3 deletions(-)

diff --git a/src/renderer/components/accounts/ImportAccountsDialog.tsx b/src/renderer/components/accounts/ImportAccountsDialog.tsx
index 3db6708..c57a1f1 100644
--- a/src/renderer/components/accounts/ImportAccountsDialog.tsx
+++ b/src/renderer/components/accounts/ImportAccountsDialog.tsx
@@ -3,7 +3,14 @@ import { useTranslation } from 'react-i18next';
 import { FiX } from 'react-icons/fi';
 import { useImportAccounts } from '../../hooks/useAccountTransfer';
 import { useToast } from '../ui/ToastProvider';
-import { humanErrorMessage } from '../../lib/result';
+import { humanErrorMessage, errorCode } from '../../lib/result';
+
+// TransferError codes from the import module → their localized message keys.
+const CODE_KEYS: Record<string, string> = {
+  PasswordRequired: 'transfer.passwordRequired',
+  IncorrectPassword: 'transfer.incorrectPassword',
+  InvalidData: 'transfer.invalidData',
+};
 
 export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => void; onImported: () => void }) {
   const { t } = useTranslation();
@@ -26,7 +33,8 @@ export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => v
       onImported();
       onClose();
     } catch (e) {
-      setError(humanErrorMessage(e));
+      const key = CODE_KEYS[errorCode(e) ?? ''];
+      setError(key ? t(key) : humanErrorMessage(e));
     }
   };
 
diff --git a/src/renderer/lib/result.test.ts b/src/renderer/lib/result.test.ts
index c8e7296..e1614a3 100644
--- a/src/renderer/lib/result.test.ts
+++ b/src/renderer/lib/result.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { unwrap, humanErrorMessage } from './result';
+import { unwrap, humanErrorMessage, errorCode } from './result';
 
 describe('unwrap', () => {
   it('returns data for an ok Result', () => {
@@ -30,3 +30,13 @@ describe('humanErrorMessage', () => {
     expect(humanErrorMessage('boom')).toBe('boom');
   });
 });
+
+describe('errorCode', () => {
+  it('returns the leading code prefix', () => {
+    expect(errorCode(new Error('IncorrectPassword: Incorrect password.'))).toBe('IncorrectPassword');
+  });
+
+  it('returns null when there is no prefix', () => {
+    expect(errorCode(new Error('plain message'))).toBeNull();
+  });
+});
diff --git a/src/renderer/lib/result.ts b/src/renderer/lib/result.ts
index ac6ac60..24725af 100644
--- a/src/renderer/lib/result.ts
+++ b/src/renderer/lib/result.ts
@@ -16,3 +16,11 @@ export function humanErrorMessage(error: unknown): string {
   const msg = error instanceof Error ? error.message : String(error);
   return msg.includes(': ') ? msg.split(': ').slice(1).join(': ') : msg;
 }
+
+/** The leading "Code" that {@link unwrap} prepends, or null if the message has
+ *  no such prefix — lets callers map known codes to localized text. */
+export function errorCode(error: unknown): string | null {
+  const msg = error instanceof Error ? error.message : String(error);
+  const i = msg.indexOf(': ');
+  return i > 0 ? msg.slice(0, i) : null;
+}

From dc891b007055ee62ed61aa966e2f749101e4cb32 Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 10:30:34 +0200
Subject: [PATCH 12/24] feat(accounts): add peekEnvelope and ImportPreview type

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/main/accounts/accountTransfer.test.ts | 18 +++++++++++++++++-
 src/main/accounts/accountTransfer.ts      | 17 ++++++++++++++++-
 2 files changed, 33 insertions(+), 2 deletions(-)

diff --git a/src/main/accounts/accountTransfer.test.ts b/src/main/accounts/accountTransfer.test.ts
index 690303e..bac3798 100644
--- a/src/main/accounts/accountTransfer.test.ts
+++ b/src/main/accounts/accountTransfer.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { exportAccounts, importAccounts, TransferError, type ExportAccount } from './accountTransfer';
+import { exportAccounts, importAccounts, TransferError, peekEnvelope, type ExportAccount } from './accountTransfer';
 
 const acc: ExportAccount = {
   label: 'AWS prod', provider: 'amazon-s3', region: 'eu-central-1',
@@ -58,3 +58,19 @@ describe('accountTransfer errors', () => {
     expect(new TransferError('InvalidData', 'x').code).toBe('InvalidData');
   });
 });
+
+describe('peekEnvelope', () => {
+  it('reports encrypted=false for a plain export', () => {
+    const blob = exportAccounts([acc]);
+    expect(peekEnvelope(blob)).toEqual({ encrypted: false });
+  });
+
+  it('reports encrypted=true for a password export', () => {
+    const blob = exportAccounts([acc], 'pw');
+    expect(peekEnvelope(blob)).toEqual({ encrypted: true });
+  });
+
+  it('throws InvalidData on garbage', () => {
+    expect(() => peekEnvelope('!!!nope!!!')).toThrow(expect.objectContaining({ code: 'InvalidData' }));
+  });
+});
diff --git a/src/main/accounts/accountTransfer.ts b/src/main/accounts/accountTransfer.ts
index b34b6d8..c7259a2 100644
--- a/src/main/accounts/accountTransfer.ts
+++ b/src/main/accounts/accountTransfer.ts
@@ -11,6 +11,11 @@ export interface ExportAccount {
   forcePathStyle?: boolean;
 }
 
+export interface ImportPreview {
+  encrypted: boolean;
+  accounts: { label: string; provider: ProviderId }[] | null;
+}
+
 export type TransferErrorCode = 'PasswordRequired' | 'IncorrectPassword' | 'InvalidData';
 
 export class TransferError extends Error {
@@ -55,7 +60,7 @@ export function exportAccounts(accounts: ExportAccount[], password?: string): st
   return Buffer.from(JSON.stringify(envelope), 'utf8').toString('base64');
 }
 
-export function importAccounts(blob: string, password?: string): ExportAccount[] {
+function parseEnvelope(blob: string): Record<string, unknown> {
   let env: Record<string, unknown>;
   try {
     const json = Buffer.from(blob.trim(), 'base64').toString('utf8');
@@ -68,6 +73,16 @@ export function importAccounts(blob: string, password?: string): ExportAccount[]
   if (env.format !== FORMAT || env.version !== VERSION || typeof env.data !== 'string') {
     throw new TransferError('InvalidData', 'The import data is not a recognized account export.');
   }
+  return env;
+}
+
+/** Report whether an export is password-encrypted, without decrypting it. */
+export function peekEnvelope(blob: string): { encrypted: boolean } {
+  return { encrypted: parseEnvelope(blob).encrypted === true };
+}
+
+export function importAccounts(blob: string, password?: string): ExportAccount[] {
+  const env = parseEnvelope(blob);
 
   let payload: string;
   if (env.encrypted === true) {

From b9c1ffb18aed6d2b85b72ec8c68c3a4f1c12a2a0 Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 10:34:54 +0200
Subject: [PATCH 13/24] feat(ipc): add accounts import preview channel

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/main/ipc/channels.ts      |  3 +++
 src/main/ipc/register.test.ts | 38 +++++++++++++++++++++++++++++++++++
 src/main/ipc/register.ts      | 25 +++++++++++++++++++++--
 src/preload.ts                |  1 +
 4 files changed, 65 insertions(+), 2 deletions(-)

diff --git a/src/main/ipc/channels.ts b/src/main/ipc/channels.ts
index 0809057..aefac07 100644
--- a/src/main/ipc/channels.ts
+++ b/src/main/ipc/channels.ts
@@ -12,6 +12,7 @@ import type { AppSettings, AppInfo } from '../settings/appSettings';
 import type { UpdateInfo } from '../update/checkForUpdate';
 import type { ObjectAcl } from '../s3/objectAcl';
 import type { EditableMetadata } from '../s3/objectMetadata';
+import type { ImportPreview } from '../accounts/accountTransfer';
 
 export const CH = {
   accountsList: 'accounts:list',
@@ -21,6 +22,7 @@ export const CH = {
   accountsTest: 'accounts:test',
   accountsExport: 'accounts:export',
   accountsImport: 'accounts:import',
+  accountsImportPreview: 'accounts:importPreview',
   encryptionAvailable: 'secrets:available',
   listBuckets: 's3:listBuckets',
   createBucket: 's3:createBucket',
@@ -110,6 +112,7 @@ export interface ApiMap {
   [CH.accountsTest]: { args: [TestAccountInput]; res: Result<true> };
   [CH.accountsExport]: { args: [{ accountIds: string[]; password?: string }]; res: Result<string> };
   [CH.accountsImport]: { args: [{ blob: string; password?: string }]; res: Result<Account[]> };
+  [CH.accountsImportPreview]: { args: [{ blob: string; password?: string }]; res: Result<ImportPreview> };
   [CH.encryptionAvailable]: { args: []; res: Result<boolean> };
   [CH.listBuckets]: { args: [string]; res: Result<string[]> };
   [CH.createBucket]: { args: [{ accountId: string; bucket: string; objectLock: boolean; versioning: boolean }]; res: Result<true> };
diff --git a/src/main/ipc/register.test.ts b/src/main/ipc/register.test.ts
index 430a974..70c99b7 100644
--- a/src/main/ipc/register.test.ts
+++ b/src/main/ipc/register.test.ts
@@ -264,6 +264,44 @@ describe('registerIpc', () => {
     expect(deps.accounts.list()).toHaveLength(0);
   });
 
+  it('accounts:importPreview returns label+provider (no secret) for a plain export', async () => {
+    const { exportAccounts } = await import('../accounts/accountTransfer');
+    const blob = exportAccounts([
+      { label: 'AWS', provider: 'amazon-s3', region: 'eu-central-1', accessKeyId: 'AK', secretAccessKey: 'SECRET' },
+    ]);
+    const { handlers } = buildHarness();
+    const res = (await handlers.get(CH.accountsImportPreview)!({ blob })) as {
+      ok: boolean;
+      data: { encrypted: boolean; accounts: { label: string; provider: string; secretAccessKey?: string }[] | null };
+    };
+    expect(res.ok).toBe(true);
+    expect(res.data.encrypted).toBe(false);
+    expect(res.data.accounts).toEqual([{ label: 'AWS', provider: 'amazon-s3' }]);
+    expect(res.data.accounts![0]).not.toHaveProperty('secretAccessKey');
+  });
+
+  it('accounts:importPreview reports encrypted without a password and previews with one', async () => {
+    const { exportAccounts } = await import('../accounts/accountTransfer');
+    const blob = exportAccounts([
+      { label: 'Enc', provider: 'amazon-s3', region: 'us-east-1', accessKeyId: 'K', secretAccessKey: 'S' },
+    ], 'pw');
+    const { handlers } = buildHarness();
+    const locked = (await handlers.get(CH.accountsImportPreview)!({ blob })) as { ok: boolean; data: { encrypted: boolean; accounts: unknown } };
+    expect(locked).toEqual({ ok: true, data: { encrypted: true, accounts: null } });
+    const opened = (await handlers.get(CH.accountsImportPreview)!({ blob, password: 'pw' })) as { ok: boolean; data: { encrypted: boolean; accounts: { label: string }[] } };
+    expect(opened.ok).toBe(true);
+    expect(opened.data.accounts).toEqual([{ label: 'Enc', provider: 'amazon-s3' }]);
+  });
+
+  it('accounts:importPreview errors on a wrong password', async () => {
+    const { exportAccounts } = await import('../accounts/accountTransfer');
+    const blob = exportAccounts([{ label: 'Enc', provider: 'amazon-s3', region: 'us-east-1', accessKeyId: 'K', secretAccessKey: 'S' }], 'pw');
+    const { handlers } = buildHarness();
+    const res = (await handlers.get(CH.accountsImportPreview)!({ blob, password: 'WRONG' })) as { ok: boolean; error: { code: string } };
+    expect(res.ok).toBe(false);
+    expect(res.error.code).toBe('IncorrectPassword');
+  });
+
   it('accounts:create rejects an unknown provider and persists nothing', async () => {
     const { handlers, deps } = buildHarness();
     const res = (await handlers.get(CH.accountsCreate)!({
diff --git a/src/main/ipc/register.ts b/src/main/ipc/register.ts
index f1359a2..1dc30ad 100644
--- a/src/main/ipc/register.ts
+++ b/src/main/ipc/register.ts
@@ -27,8 +27,8 @@ import type { ObjectAcl } from '../s3/objectAcl';
 import { getEditableMetadata, updateObjectMetadata } from '../s3/objectMetadata';
 import { createFolder, moveObject, moveFolder } from '../s3/transfer';
 import { createBucket } from '../s3/buckets';
-import { exportAccounts, importAccounts, TransferError } from '../accounts/accountTransfer';
-import type { ExportAccount } from '../accounts/accountTransfer';
+import { exportAccounts, importAccounts, TransferError, peekEnvelope } from '../accounts/accountTransfer';
+import type { ExportAccount, ImportPreview } from '../accounts/accountTransfer';
 import { checkForUpdate } from '../update/checkForUpdate';
 import { planSync, runSync, type Endpoint } from '../s3/sync';
 import { planLocalSync, runLocalSync } from '../s3/localSync';
@@ -260,6 +260,27 @@ export function registerIpc(ipcMain: IpcMainLike, deps: RegisterDeps): void {
     return ok(created);
   });
 
+  h(CH.accountsImportPreview, (a: { blob: string; password?: string }): Result<ImportPreview> => {
+    let encrypted: boolean;
+    try {
+      encrypted = peekEnvelope(a.blob).encrypted;
+    } catch (e) {
+      if (e instanceof TransferError) return err(e.code, e.message);
+      throw e;
+    }
+    if (encrypted && !a.password) {
+      return ok({ encrypted: true, accounts: null });
+    }
+    let parsed: ExportAccount[];
+    try {
+      parsed = importAccounts(a.blob, a.password);
+    } catch (e) {
+      if (e instanceof TransferError) return err(e.code, e.message);
+      throw e;
+    }
+    return ok({ encrypted, accounts: parsed.map((acc) => ({ label: acc.label, provider: acc.provider })) });
+  });
+
   h(CH.listBuckets, (accountId: string) => listBuckets(clientFor(accountId)));
 
   h(CH.createBucket, (a: { accountId: string; bucket: string; objectLock: boolean; versioning: boolean }) => {
diff --git a/src/preload.ts b/src/preload.ts
index ace584f..dee68c3 100644
--- a/src/preload.ts
+++ b/src/preload.ts
@@ -17,6 +17,7 @@ const api = {
     test: (input: ApiMap[typeof CH.accountsTest]['args'][0]) => invoke(CH.accountsTest, input),
     export: (a: ApiMap[typeof CH.accountsExport]['args'][0]) => invoke(CH.accountsExport, a),
     import: (a: ApiMap[typeof CH.accountsImport]['args'][0]) => invoke(CH.accountsImport, a),
+    importPreview: (a: ApiMap[typeof CH.accountsImportPreview]['args'][0]) => invoke(CH.accountsImportPreview, a),
   },
   encryptionAvailable: () => invoke(CH.encryptionAvailable),
   listBuckets: (accountId: string) => invoke(CH.listBuckets, accountId),

From 5f6a76f1f10d39bbe30be2ccd54277508f33ea8e Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 10:36:08 +0200
Subject: [PATCH 14/24] fix(accounts): restore string narrowing lost in
 parseEnvelope extraction

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/main/accounts/accountTransfer.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/accounts/accountTransfer.ts b/src/main/accounts/accountTransfer.ts
index c7259a2..ab1fb50 100644
--- a/src/main/accounts/accountTransfer.ts
+++ b/src/main/accounts/accountTransfer.ts
@@ -104,7 +104,7 @@ export function importAccounts(blob: string, password?: string): ExportAccount[]
       throw new TransferError('IncorrectPassword', 'Incorrect password or corrupted data.');
     }
   } else {
-    payload = env.data;
+    payload = env.data as string; // parseEnvelope validated typeof env.data === 'string'
   }
 
   let parsedPayload: unknown;

From aea77e266cbcf6b880d79a02ecde55c187280757 Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 10:39:34 +0200
Subject: [PATCH 15/24] feat(accounts): add useImportPreview hook

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/renderer/hooks/useAccountTransfer.test.tsx | 11 ++++++++++-
 src/renderer/hooks/useAccountTransfer.ts       |  7 +++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/renderer/hooks/useAccountTransfer.test.tsx b/src/renderer/hooks/useAccountTransfer.test.tsx
index 313bf08..8038792 100644
--- a/src/renderer/hooks/useAccountTransfer.test.tsx
+++ b/src/renderer/hooks/useAccountTransfer.test.tsx
@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { renderHook, waitFor } from '@testing-library/react';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import type { ReactNode } from 'react';
-import { useExportAccounts, useImportAccounts } from './useAccountTransfer';
+import { useExportAccounts, useImportAccounts, useImportPreview } from './useAccountTransfer';
 
 function wrapper() {
   const client = new QueryClient({ defaultOptions: { mutations: { retry: false } } });
@@ -16,6 +16,7 @@ beforeEach(() => {
     accounts: {
       export: vi.fn().mockResolvedValue({ ok: true, data: 'BLOB' }),
       import: vi.fn().mockResolvedValue({ ok: true, data: [{ id: 'n1' }] }),
+      importPreview: vi.fn().mockResolvedValue({ ok: true, data: { encrypted: false, accounts: [{ label: 'AWS', provider: 'amazon-s3' }] } }),
     },
   };
 });
@@ -37,3 +38,11 @@ describe('useImportAccounts', () => {
     await waitFor(() => expect(result.current.data).toEqual([{ id: 'n1' }]));
   });
 });
+
+describe('useImportPreview', () => {
+  it('returns the preview payload', async () => {
+    const { result } = renderHook(() => useImportPreview(), { wrapper: wrapper() });
+    result.current.mutate({ blob: 'BLOB' });
+    await waitFor(() => expect(result.current.data).toEqual({ encrypted: false, accounts: [{ label: 'AWS', provider: 'amazon-s3' }] }));
+  });
+});
diff --git a/src/renderer/hooks/useAccountTransfer.ts b/src/renderer/hooks/useAccountTransfer.ts
index f03108e..0a76a3b 100644
--- a/src/renderer/hooks/useAccountTransfer.ts
+++ b/src/renderer/hooks/useAccountTransfer.ts
@@ -17,3 +17,10 @@ export function useImportAccounts() {
     onSuccess: () => qc.invalidateQueries({ queryKey: accountsKey }),
   });
 }
+
+export function useImportPreview() {
+  return useMutation({
+    mutationFn: async (input: { blob: string; password?: string }) =>
+      unwrap(await window.s3.accounts.importPreview(input)),
+  });
+}

From e20eedb3a4bd7232e41e7352f8659269fbc7860d Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 10:41:18 +0200
Subject: [PATCH 16/24] feat(accounts): hide export password field after
 generating

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../accounts/ExportAccountsDialog.test.tsx    |  8 ++++
 .../accounts/ExportAccountsDialog.tsx         | 37 ++++++++++---------
 2 files changed, 27 insertions(+), 18 deletions(-)

diff --git a/src/renderer/components/accounts/ExportAccountsDialog.test.tsx b/src/renderer/components/accounts/ExportAccountsDialog.test.tsx
index 964b655..7a40014 100644
--- a/src/renderer/components/accounts/ExportAccountsDialog.test.tsx
+++ b/src/renderer/components/accounts/ExportAccountsDialog.test.tsx
@@ -56,4 +56,12 @@ describe('ExportAccountsDialog', () => {
     await userEvent.click(screen.getByRole('button', { name: 'Generate export' }));
     expect(await screen.findByText(/Cannot read the secret\./)).toBeInTheDocument();
   });
+
+  it('hides the password field once the export string is shown', async () => {
+    wrap(<ExportAccountsDialog accountIds={['a']} onClose={() => {}} />);
+    expect(screen.getByLabelText('Password (optional)')).toBeInTheDocument();
+    await userEvent.click(screen.getByRole('button', { name: 'Generate export' }));
+    await screen.findByLabelText('Export string');
+    expect(screen.queryByLabelText('Password (optional)')).not.toBeInTheDocument();
+  });
 });
diff --git a/src/renderer/components/accounts/ExportAccountsDialog.tsx b/src/renderer/components/accounts/ExportAccountsDialog.tsx
index 09b9517..c80acf2 100644
--- a/src/renderer/components/accounts/ExportAccountsDialog.tsx
+++ b/src/renderer/components/accounts/ExportAccountsDialog.tsx
@@ -43,25 +43,26 @@ export function ExportAccountsDialog({ accountIds, onClose }: { accountIds: stri
           </button>
         </div>
 
-        <label className="block text-sm">
-          {t('transfer.password')}
-          <input type="password" className={field} value={password} onChange={(e) => setPassword(e.target.value)} />
-        </label>
-        {password.length === 0 && (
-          <p className="mt-2 text-xs text-amber-600 dark:text-amber-400">{t('transfer.noPasswordWarning')}</p>
-        )}
-
         {result === null ? (
-          <div className="mt-4 flex justify-end">
-            <button
-              type="button"
-              disabled={exportAccounts.isPending}
-              className="rounded bg-slate-800 px-3 py-1 text-sm text-white hover:bg-slate-700 disabled:opacity-40 dark:bg-slate-200 dark:text-slate-900"
-              onClick={onGenerate}
-            >
-              {t('transfer.generate')}
-            </button>
-          </div>
+          <>
+            <label className="block text-sm">
+              {t('transfer.password')}
+              <input type="password" className={field} value={password} onChange={(e) => setPassword(e.target.value)} />
+            </label>
+            {password.length === 0 && (
+              <p className="mt-2 text-xs text-amber-600 dark:text-amber-400">{t('transfer.noPasswordWarning')}</p>
+            )}
+            <div className="mt-4 flex justify-end">
+              <button
+                type="button"
+                disabled={exportAccounts.isPending}
+                className="rounded bg-slate-800 px-3 py-1 text-sm text-white hover:bg-slate-700 disabled:opacity-40 dark:bg-slate-200 dark:text-slate-900"
+                onClick={onGenerate}
+              >
+                {t('transfer.generate')}
+              </button>
+            </div>
+          </>
         ) : (
           <>
             <textarea

From cc148a79c7f2c92c0aa90cd014662fc80391c53b Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 10:46:17 +0200
Subject: [PATCH 17/24] feat(accounts): import preview with conditional
 password field

Reworks ImportAccountsDialog with a debounced background preview (350 ms),
conditional password field for encrypted exports, an account preview list,
and a gated Import button (disabled until accounts are previewed). Adds
previewCount, encryptedHint, and checking i18n keys to all 6 locales.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../accounts/ImportAccountsDialog.test.tsx    | 73 +++++++++++----
 .../accounts/ImportAccountsDialog.tsx         | 89 ++++++++++++++++---
 src/renderer/i18n/locales/de.json             |  5 +-
 src/renderer/i18n/locales/en.json             |  5 +-
 src/renderer/i18n/locales/fr.json             |  5 +-
 src/renderer/i18n/locales/nl.json             |  5 +-
 src/renderer/i18n/locales/pl.json             |  5 +-
 src/renderer/i18n/locales/ro.json             |  5 +-
 8 files changed, 158 insertions(+), 34 deletions(-)

diff --git a/src/renderer/components/accounts/ImportAccountsDialog.test.tsx b/src/renderer/components/accounts/ImportAccountsDialog.test.tsx
index 896a4f9..69d0354 100644
--- a/src/renderer/components/accounts/ImportAccountsDialog.test.tsx
+++ b/src/renderer/components/accounts/ImportAccountsDialog.test.tsx
@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { render, screen, waitFor } from '@testing-library/react';
+import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import type { ReactNode } from 'react';
@@ -15,40 +15,77 @@ function wrap(node: ReactNode) {
   );
 }
 
-beforeEach(() => {
+function setS3(over: Record<string, unknown> = {}) {
   (window as unknown as { s3: unknown }).s3 = {
-    accounts: { import: vi.fn().mockResolvedValue({ ok: true, data: [{ id: 'n1' }, { id: 'n2' }] }) },
+    accounts: {
+      import: vi.fn().mockResolvedValue({ ok: true, data: [{ id: 'n1' }] }),
+      importPreview: vi.fn().mockResolvedValue({ ok: true, data: { encrypted: false, accounts: [{ label: 'AWS prod', provider: 'amazon-s3' }] } }),
+      ...over,
+    },
     openTextFile: vi.fn().mockResolvedValue({ ok: true, data: 'FILE-BLOB' }),
   };
-});
+}
+
+beforeEach(() => setS3());
 
 describe('ImportAccountsDialog', () => {
-  it('imports a pasted blob and reports the count', async () => {
+  it('previews an unencrypted blob: shows the list, no password field, import enabled', async () => {
+    wrap(<ImportAccountsDialog onClose={() => {}} onImported={() => {}} />);
+    await userEvent.type(screen.getByLabelText('Import data'), 'BLOB');
+    expect(await screen.findByText('AWS prod (Amazon S3)')).toBeInTheDocument();
+    expect(screen.queryByLabelText('Password')).not.toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Import' })).toBeEnabled();
+  });
+
+  it('imports after previewing and reports the count', async () => {
     const onImported = vi.fn();
     const onClose = vi.fn();
     wrap(<ImportAccountsDialog onClose={onClose} onImported={onImported} />);
     await userEvent.type(screen.getByLabelText('Import data'), 'BLOB');
+    await screen.findByText('AWS prod (Amazon S3)');
     await userEvent.click(screen.getByRole('button', { name: 'Import' }));
-    await waitFor(() => expect(onImported).toHaveBeenCalled());
+    await screen.findByText('AWS prod (Amazon S3)');
     expect(window.s3.accounts.import).toHaveBeenCalledWith({ blob: 'BLOB', password: undefined });
+    expect(onImported).toHaveBeenCalled();
     expect(onClose).toHaveBeenCalled();
   });
 
-  it('loads a file into the textarea', async () => {
+  it('shows the password field for an encrypted blob and previews after the password', async () => {
+    setS3({
+      importPreview: vi.fn().mockImplementation(async (input: { password?: string }) =>
+        input.password
+          ? { ok: true, data: { encrypted: true, accounts: [{ label: 'Hetzner', provider: 'hetzner' }] } }
+          : { ok: true, data: { encrypted: true, accounts: null } },
+      ),
+    });
     wrap(<ImportAccountsDialog onClose={() => {}} onImported={() => {}} />);
-    await userEvent.click(screen.getByRole('button', { name: 'Load file' }));
-    await waitFor(() => expect(screen.getByLabelText('Import data')).toHaveValue('FILE-BLOB'));
+    await userEvent.type(screen.getByLabelText('Import data'), 'ENC');
+    const pw = await screen.findByLabelText('Password');
+    expect(screen.getByRole('button', { name: 'Import' })).toBeDisabled();
+    await userEvent.type(pw, 'secret');
+    expect(await screen.findByText('Hetzner (Hetzner Object Storage)')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Import' })).toBeEnabled();
   });
 
-  it('shows an inline error and stays open on an incorrect password', async () => {
-    (window.s3 as unknown as { accounts: { import: ReturnType<typeof vi.fn> } }).accounts.import = vi
-      .fn()
-      .mockResolvedValue({ ok: false, error: { code: 'IncorrectPassword', message: 'Incorrect password.' } });
-    const onClose = vi.fn();
-    wrap(<ImportAccountsDialog onClose={onClose} onImported={() => {}} />);
-    await userEvent.type(screen.getByLabelText('Import data'), 'BLOB');
-    await userEvent.click(screen.getByRole('button', { name: 'Import' }));
+  it('shows an inline error on an incorrect password and keeps Import disabled', async () => {
+    setS3({
+      importPreview: vi.fn().mockImplementation(async (input: { password?: string }) =>
+        input.password
+          ? { ok: false, error: { code: 'IncorrectPassword', message: 'Incorrect password.' } }
+          : { ok: true, data: { encrypted: true, accounts: null } },
+      ),
+    });
+    wrap(<ImportAccountsDialog onClose={() => {}} onImported={() => {}} />);
+    await userEvent.type(screen.getByLabelText('Import data'), 'ENC');
+    const pw = await screen.findByLabelText('Password');
+    await userEvent.type(pw, 'wrong');
     expect(await screen.findByText('Incorrect password.')).toBeInTheDocument();
-    expect(onClose).not.toHaveBeenCalled();
+    expect(screen.getByRole('button', { name: 'Import' })).toBeDisabled();
+  });
+
+  it('loads a file into the textarea', async () => {
+    wrap(<ImportAccountsDialog onClose={() => {}} onImported={() => {}} />);
+    await userEvent.click(screen.getByRole('button', { name: 'Load file' }));
+    expect(await screen.findByDisplayValue('FILE-BLOB')).toBeInTheDocument();
   });
 });
diff --git a/src/renderer/components/accounts/ImportAccountsDialog.tsx b/src/renderer/components/accounts/ImportAccountsDialog.tsx
index c57a1f1..c0e6ca9 100644
--- a/src/renderer/components/accounts/ImportAccountsDialog.tsx
+++ b/src/renderer/components/accounts/ImportAccountsDialog.tsx
@@ -1,24 +1,72 @@
-import { useState } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { FiX } from 'react-icons/fi';
-import { useImportAccounts } from '../../hooks/useAccountTransfer';
+import { useImportAccounts, useImportPreview } from '../../hooks/useAccountTransfer';
 import { useToast } from '../ui/ToastProvider';
 import { humanErrorMessage, errorCode } from '../../lib/result';
+import { UI_PROVIDERS } from '../../lib/providers';
+import type { ImportPreview } from '../../../main/accounts/accountTransfer';
 
-// TransferError codes from the import module → their localized message keys.
+// TransferError codes → their localized message keys.
 const CODE_KEYS: Record<string, string> = {
-  PasswordRequired: 'transfer.passwordRequired',
   IncorrectPassword: 'transfer.incorrectPassword',
   InvalidData: 'transfer.invalidData',
 };
 
+function providerLabel(provider: string): string {
+  return UI_PROVIDERS.find((p) => p.id === provider)?.label ?? provider;
+}
+
 export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => void; onImported: () => void }) {
   const { t } = useTranslation();
   const { show } = useToast();
   const importAccounts = useImportAccounts();
+  const importPreview = useImportPreview();
   const [blob, setBlob] = useState('');
   const [password, setPassword] = useState('');
+  const [encrypted, setEncrypted] = useState(false);
+  const [preview, setPreview] = useState<ImportPreview | null>(null);
+  const [previewError, setPreviewError] = useState<string | null>(null);
+  const [checking, setChecking] = useState(false);
   const [error, setError] = useState<string | null>(null);
+  const reqId = useRef(0);
+
+  // Background, debounced preview whenever the blob or password changes.
+  useEffect(() => {
+    if (blob.trim().length === 0) {
+      setPreview(null);
+      setPreviewError(null);
+      setEncrypted(false);
+      setChecking(false);
+      return;
+    }
+    setChecking(true);
+    const id = ++reqId.current;
+    const handle = setTimeout(() => {
+      importPreview
+        .mutateAsync({ blob, password: password || undefined })
+        .then((data) => {
+          if (id !== reqId.current) return;
+          setEncrypted(data.encrypted);
+          setPreview(data);
+          setPreviewError(null);
+        })
+        .catch((e) => {
+          if (id !== reqId.current) return;
+          const code = errorCode(e);
+          if (code === 'IncorrectPassword') setEncrypted(true);
+          else if (code === 'InvalidData') setEncrypted(false);
+          setPreview(null);
+          const key = CODE_KEYS[code ?? ''];
+          setPreviewError(key ? t(key) : humanErrorMessage(e));
+        })
+        .finally(() => {
+          if (id === reqId.current) setChecking(false);
+        });
+    }, 350);
+    return () => clearTimeout(handle);
+    // importPreview.mutateAsync and t are stable; intentionally keyed on blob+password.
+  }, [blob, password]);
 
   const onLoadFile = async () => {
     const text = await window.s3.openTextFile();
@@ -38,6 +86,7 @@ export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => v
     }
   };
 
+  const accounts = preview?.accounts ?? null;
   const field = 'mt-1 w-full rounded border border-slate-300 px-2 py-1 text-sm dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100';
 
   return (
@@ -55,7 +104,7 @@ export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => v
           placeholder={t('transfer.pastePlaceholder')}
           value={blob}
           onChange={(e) => setBlob(e.target.value)}
-          className="h-28 w-full resize-none rounded border border-slate-300 p-2 font-mono text-xs dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100"
+          className="h-24 w-full resize-none rounded border border-slate-300 p-2 font-mono text-xs dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100"
         />
         <div className="mt-2">
           <button type="button" className="rounded border border-slate-300 px-3 py-1 text-sm hover:bg-slate-50 dark:border-slate-700 dark:hover:bg-slate-800" onClick={onLoadFile}>
@@ -63,10 +112,30 @@ export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => v
           </button>
         </div>
 
-        <label className="mt-3 block text-sm">
-          {t('transfer.importPassword')}
-          <input type="password" className={field} value={password} onChange={(e) => setPassword(e.target.value)} />
-        </label>
+        {encrypted && (
+          <label className="mt-3 block text-sm">
+            {t('transfer.importPassword')}
+            <input type="password" className={field} value={password} onChange={(e) => setPassword(e.target.value)} />
+          </label>
+        )}
+
+        <div className="mt-3 text-sm" aria-live="polite">
+          {checking && <span className="text-slate-500 dark:text-slate-400">{t('transfer.checking')}</span>}
+          {!checking && previewError !== null && <span className="text-red-600 dark:text-red-400">{previewError}</span>}
+          {!checking && previewError === null && encrypted && accounts === null && (
+            <span className="text-slate-500 dark:text-slate-400">{t('transfer.encryptedHint')}</span>
+          )}
+          {!checking && accounts !== null && (
+            <div>
+              <p className="text-slate-700 dark:text-slate-200">{t('transfer.previewCount', { count: accounts.length })}</p>
+              <ul className="mt-1 max-h-32 overflow-auto text-slate-600 dark:text-slate-300">
+                {accounts.map((a, i) => (
+                  <li key={i}>{a.label} ({providerLabel(a.provider)})</li>
+                ))}
+              </ul>
+            </div>
+          )}
+        </div>
 
         {error !== null && <p className="mt-2 text-xs text-red-600 dark:text-red-400">{error}</p>}
 
@@ -76,7 +145,7 @@ export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => v
           </button>
           <button
             type="button"
-            disabled={blob.trim().length === 0 || importAccounts.isPending}
+            disabled={accounts === null || importAccounts.isPending}
             className="rounded bg-slate-800 px-3 py-1 text-sm text-white hover:bg-slate-700 disabled:opacity-40 dark:bg-slate-200 dark:text-slate-900"
             onClick={onImport}
           >
diff --git a/src/renderer/i18n/locales/de.json b/src/renderer/i18n/locales/de.json
index 8e76694..8f9b188 100644
--- a/src/renderer/i18n/locales/de.json
+++ b/src/renderer/i18n/locales/de.json
@@ -347,7 +347,10 @@
     "imported": "{{count}} Konten importiert",
     "importAccounts": "Importieren",
     "exportAll": "Alle exportieren",
-    "exportAria": "{{label}} exportieren"
+    "exportAria": "{{label}} exportieren",
+    "previewCount": "{{count}} Konten werden importiert",
+    "encryptedHint": "Verschlüsselt — Passwort zur Vorschau eingeben",
+    "checking": "Wird geprüft…"
   },
   "dashboard": {
     "title": "Dashboard",
diff --git a/src/renderer/i18n/locales/en.json b/src/renderer/i18n/locales/en.json
index 218952c..5c495ee 100644
--- a/src/renderer/i18n/locales/en.json
+++ b/src/renderer/i18n/locales/en.json
@@ -347,7 +347,10 @@
     "imported": "Imported {{count}} accounts",
     "importAccounts": "Import",
     "exportAll": "Export all",
-    "exportAria": "Export {{label}}"
+    "exportAria": "Export {{label}}",
+    "previewCount": "{{count}} accounts will be imported",
+    "encryptedHint": "Encrypted — enter the password to preview",
+    "checking": "Checking…"
   },
   "dashboard": {
     "title": "Dashboard",
diff --git a/src/renderer/i18n/locales/fr.json b/src/renderer/i18n/locales/fr.json
index c580a34..7ed47fd 100644
--- a/src/renderer/i18n/locales/fr.json
+++ b/src/renderer/i18n/locales/fr.json
@@ -347,7 +347,10 @@
     "imported": "{{count}} comptes importés",
     "importAccounts": "Importer",
     "exportAll": "Tout exporter",
-    "exportAria": "Exporter {{label}}"
+    "exportAria": "Exporter {{label}}",
+    "previewCount": "{{count}} comptes seront importés",
+    "encryptedHint": "Chiffré — saisissez le mot de passe pour prévisualiser",
+    "checking": "Vérification…"
   },
   "dashboard": {
     "title": "Tableau de bord",
diff --git a/src/renderer/i18n/locales/nl.json b/src/renderer/i18n/locales/nl.json
index f2d1a95..2bc8d62 100644
--- a/src/renderer/i18n/locales/nl.json
+++ b/src/renderer/i18n/locales/nl.json
@@ -347,7 +347,10 @@
     "imported": "{{count}} accounts geïmporteerd",
     "importAccounts": "Importeren",
     "exportAll": "Alles exporteren",
-    "exportAria": "{{label}} exporteren"
+    "exportAria": "{{label}} exporteren",
+    "previewCount": "{{count}} accounts worden geïmporteerd",
+    "encryptedHint": "Versleuteld — voer het wachtwoord in voor een voorbeeld",
+    "checking": "Controleren…"
   },
   "dashboard": {
     "title": "Dashboard",
diff --git a/src/renderer/i18n/locales/pl.json b/src/renderer/i18n/locales/pl.json
index 0a91081..a572fbe 100644
--- a/src/renderer/i18n/locales/pl.json
+++ b/src/renderer/i18n/locales/pl.json
@@ -351,7 +351,10 @@
     "imported": "Zaimportowano {{count}} kont",
     "importAccounts": "Importuj",
     "exportAll": "Eksportuj wszystkie",
-    "exportAria": "Eksportuj {{label}}"
+    "exportAria": "Eksportuj {{label}}",
+    "previewCount": "Zostanie zaimportowanych {{count}} kont",
+    "encryptedHint": "Zaszyfrowane — wprowadź hasło, aby wyświetlić podgląd",
+    "checking": "Sprawdzanie…"
   },
   "dashboard": {
     "title": "Pulpit",
diff --git a/src/renderer/i18n/locales/ro.json b/src/renderer/i18n/locales/ro.json
index 3ac13f9..66c70fd 100644
--- a/src/renderer/i18n/locales/ro.json
+++ b/src/renderer/i18n/locales/ro.json
@@ -349,7 +349,10 @@
     "imported": "{{count}} conturi importate",
     "importAccounts": "Importă",
     "exportAll": "Exportă tot",
-    "exportAria": "Exportă {{label}}"
+    "exportAria": "Exportă {{label}}",
+    "previewCount": "{{count}} conturi vor fi importate",
+    "encryptedHint": "Criptat — introdu parola pentru previzualizare",
+    "checking": "Se verifică…"
   },
   "dashboard": {
     "title": "Tablou de bord",

From 81981afe7e8773dee2502c18ca3d3ca561b8247b Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 11:03:10 +0200
Subject: [PATCH 18/24] feat(accounts): import duplicate mode
 (skip/copy/replace)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/main/ipc/channels.ts                 |  2 +-
 src/main/ipc/register.test.ts            | 39 ++++++++++++++++++++++++
 src/main/ipc/register.ts                 | 33 ++++++++++++++------
 src/renderer/hooks/useAccountTransfer.ts |  2 +-
 4 files changed, 65 insertions(+), 11 deletions(-)

diff --git a/src/main/ipc/channels.ts b/src/main/ipc/channels.ts
index aefac07..345983b 100644
--- a/src/main/ipc/channels.ts
+++ b/src/main/ipc/channels.ts
@@ -111,7 +111,7 @@ export interface ApiMap {
   [CH.accountsRemove]: { args: [string]; res: Result<true> };
   [CH.accountsTest]: { args: [TestAccountInput]; res: Result<true> };
   [CH.accountsExport]: { args: [{ accountIds: string[]; password?: string }]; res: Result<string> };
-  [CH.accountsImport]: { args: [{ blob: string; password?: string }]; res: Result<Account[]> };
+  [CH.accountsImport]: { args: [{ blob: string; password?: string; onDuplicate?: 'skip' | 'copy' | 'replace' }]; res: Result<Account[]> };
   [CH.accountsImportPreview]: { args: [{ blob: string; password?: string }]; res: Result<ImportPreview> };
   [CH.encryptionAvailable]: { args: []; res: Result<boolean> };
   [CH.listBuckets]: { args: [string]; res: Result<string[]> };
diff --git a/src/main/ipc/register.test.ts b/src/main/ipc/register.test.ts
index 70c99b7..e3040b5 100644
--- a/src/main/ipc/register.test.ts
+++ b/src/main/ipc/register.test.ts
@@ -302,6 +302,45 @@ describe('registerIpc', () => {
     expect(res.error.code).toBe('IncorrectPassword');
   });
 
+  it('accounts:import skips a same-named account when onDuplicate=skip', async () => {
+    const { exportAccounts } = await import('../accounts/accountTransfer');
+    const { handlers, deps } = buildHarness();
+    await handlers.get(CH.accountsCreate)!({ label: 'AWS', provider: 'amazon-s3', region: 'eu-central-1', accessKeyId: 'OLD', secretAccessKey: 'OLDS' });
+    const blob = exportAccounts([
+      { label: 'AWS', provider: 'amazon-s3', region: 'us-east-1', accessKeyId: 'NEW', secretAccessKey: 'NEWS' },
+      { label: 'Fresh', provider: 'amazon-s3', region: 'us-east-1', accessKeyId: 'FK', secretAccessKey: 'FS' },
+    ]);
+    const res = (await handlers.get(CH.accountsImport)!({ blob, onDuplicate: 'skip' })) as { ok: boolean; data: { label: string }[] };
+    expect(res.ok).toBe(true);
+    expect(res.data.map((a) => a.label)).toEqual(['Fresh']);
+    expect(deps.accounts.list().filter((a) => a.label === 'AWS')).toHaveLength(1);
+    expect(deps.accounts.list().find((a) => a.label === 'AWS')!.accessKeyId).toBe('OLD');
+  });
+
+  it('accounts:import creates a copy when onDuplicate=copy (default)', async () => {
+    const { exportAccounts } = await import('../accounts/accountTransfer');
+    const { handlers, deps } = buildHarness();
+    await handlers.get(CH.accountsCreate)!({ label: 'AWS', provider: 'amazon-s3', region: 'eu-central-1', accessKeyId: 'OLD', secretAccessKey: 'OLDS' });
+    const blob = exportAccounts([{ label: 'AWS', provider: 'amazon-s3', region: 'us-east-1', accessKeyId: 'NEW', secretAccessKey: 'NEWS' }]);
+    const res = (await handlers.get(CH.accountsImport)!({ blob })) as { ok: boolean };
+    expect(res.ok).toBe(true);
+    expect(deps.accounts.list().filter((a) => a.label === 'AWS')).toHaveLength(2);
+  });
+
+  it('accounts:import overwrites the existing account when onDuplicate=replace', async () => {
+    const { exportAccounts } = await import('../accounts/accountTransfer');
+    const { handlers, deps } = buildHarness();
+    const created = (await handlers.get(CH.accountsCreate)!({ label: 'AWS', provider: 'amazon-s3', region: 'eu-central-1', accessKeyId: 'OLD', secretAccessKey: 'OLDS' })) as { data: { id: string } };
+    const blob = exportAccounts([{ label: 'AWS', provider: 'amazon-s3', region: 'us-east-1', accessKeyId: 'NEW', secretAccessKey: 'NEWS' }]);
+    const res = (await handlers.get(CH.accountsImport)!({ blob, onDuplicate: 'replace' })) as { ok: boolean; data: { id: string }[] };
+    expect(res.ok).toBe(true);
+    const list = deps.accounts.list().filter((a) => a.label === 'AWS');
+    expect(list).toHaveLength(1);
+    expect(list[0].id).toBe(created.data.id);
+    expect(list[0].accessKeyId).toBe('NEW');
+    expect(deps.secrets.get(created.data.id)).toBe('NEWS');
+  });
+
   it('accounts:create rejects an unknown provider and persists nothing', async () => {
     const { handlers, deps } = buildHarness();
     const res = (await handlers.get(CH.accountsCreate)!({
diff --git a/src/main/ipc/register.ts b/src/main/ipc/register.ts
index 1dc30ad..4a7b172 100644
--- a/src/main/ipc/register.ts
+++ b/src/main/ipc/register.ts
@@ -226,7 +226,7 @@ export function registerIpc(ipcMain: IpcMainLike, deps: RegisterDeps): void {
     return ok(exportAccounts(accounts, a.password));
   });
 
-  h(CH.accountsImport, (a: { blob: string; password?: string }) => {
+  h(CH.accountsImport, (a: { blob: string; password?: string; onDuplicate?: 'skip' | 'copy' | 'replace' }) => {
     let parsed: ExportAccount[];
     try {
       parsed = importAccounts(a.blob, a.password);
@@ -243,21 +243,36 @@ export function registerIpc(ipcMain: IpcMainLike, deps: RegisterDeps): void {
       if (!params.ok) return params;
       resolved.push({ acc, params: params.data });
     }
-    const created = deps.db.transaction(() => {
-      return resolved.map(({ acc, params }) => {
-        const a2 = deps.accounts.create({
+    const mode = a.onDuplicate ?? 'copy';
+    const existing = deps.accounts.list();
+    const result = deps.db.transaction(() => {
+      const out: import('../storage/accountsRepo').Account[] = [];
+      for (const { acc, params } of resolved) {
+        const dup = existing.find((e) => e.label === acc.label);
+        const fields = {
           label: acc.label,
           provider: acc.provider,
           endpoint: params.endpoint,
           region: acc.region,
           accessKeyId: acc.accessKeyId,
           forcePathStyle: params.forcePathStyle,
-        });
-        deps.secrets.set(a2.id, acc.secretAccessKey);
-        return a2;
-      });
+        };
+        if (dup && mode === 'skip') {
+          continue;
+        }
+        if (dup && mode === 'replace') {
+          const updated = deps.accounts.update(dup.id, fields);
+          deps.secrets.set(dup.id, acc.secretAccessKey);
+          out.push(updated);
+        } else {
+          const a2 = deps.accounts.create(fields);
+          deps.secrets.set(a2.id, acc.secretAccessKey);
+          out.push(a2);
+        }
+      }
+      return out;
     })();
-    return ok(created);
+    return ok(result);
   });
 
   h(CH.accountsImportPreview, (a: { blob: string; password?: string }): Result<ImportPreview> => {
diff --git a/src/renderer/hooks/useAccountTransfer.ts b/src/renderer/hooks/useAccountTransfer.ts
index 0a76a3b..ca3c2bf 100644
--- a/src/renderer/hooks/useAccountTransfer.ts
+++ b/src/renderer/hooks/useAccountTransfer.ts
@@ -12,7 +12,7 @@ export function useExportAccounts() {
 export function useImportAccounts() {
   const qc = useQueryClient();
   return useMutation({
-    mutationFn: async (input: { blob: string; password?: string }) =>
+    mutationFn: async (input: { blob: string; password?: string; onDuplicate?: 'skip' | 'copy' | 'replace' }) =>
       unwrap(await window.s3.accounts.import(input)),
     onSuccess: () => qc.invalidateQueries({ queryKey: accountsKey }),
   });

From 9431f91f8cd6ccf9d551b9d6022077467bb851c0 Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 11:06:54 +0200
Subject: [PATCH 19/24] refactor(ipc): use top-level Account import in import
 handler

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/main/ipc/register.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/ipc/register.ts b/src/main/ipc/register.ts
index 4a7b172..f6d4082 100644
--- a/src/main/ipc/register.ts
+++ b/src/main/ipc/register.ts
@@ -34,7 +34,7 @@ import { planSync, runSync, type Endpoint } from '../s3/sync';
 import { planLocalSync, runLocalSync } from '../s3/localSync';
 import type { LocalSyncArgs } from '../s3/localSync';
 import type { DefaultRetention } from '../s3/objectLock';
-import type { AccountsRepo } from '../storage/accountsRepo';
+import type { AccountsRepo, Account } from '../storage/accountsRepo';
 import type { SecretsStore, Crypto } from '../storage/secrets';
 import type { SettingsRepo } from '../storage/settingsRepo';
 import type { DB } from '../storage/db';
@@ -246,7 +246,7 @@ export function registerIpc(ipcMain: IpcMainLike, deps: RegisterDeps): void {
     const mode = a.onDuplicate ?? 'copy';
     const existing = deps.accounts.list();
     const result = deps.db.transaction(() => {
-      const out: import('../storage/accountsRepo').Account[] = [];
+      const out: Account[] = [];
       for (const { acc, params } of resolved) {
         const dup = existing.find((e) => e.label === acc.label);
         const fields = {

From e3a5876fd97e2158c45ce7ce3c8398c925bf3455 Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 11:08:39 +0200
Subject: [PATCH 20/24] feat(ui): add dismissible Modal wrapper (Esc +
 backdrop)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/renderer/components/ui/Modal.test.tsx | 33 +++++++++++++++++++++++
 src/renderer/components/ui/Modal.tsx      | 32 ++++++++++++++++++++++
 2 files changed, 65 insertions(+)
 create mode 100644 src/renderer/components/ui/Modal.test.tsx
 create mode 100644 src/renderer/components/ui/Modal.tsx

diff --git a/src/renderer/components/ui/Modal.test.tsx b/src/renderer/components/ui/Modal.test.tsx
new file mode 100644
index 0000000..aebdc81
--- /dev/null
+++ b/src/renderer/components/ui/Modal.test.tsx
@@ -0,0 +1,33 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { Modal } from './Modal';
+
+describe('Modal', () => {
+  it('renders a dialog with the panel content', () => {
+    render(<Modal onDismiss={() => {}} className="w-96">hi</Modal>);
+    expect(screen.getByRole('dialog')).toBeInTheDocument();
+    expect(screen.getByText('hi')).toBeInTheDocument();
+  });
+
+  it('dismisses on Escape', async () => {
+    const onDismiss = vi.fn();
+    render(<Modal onDismiss={onDismiss}>hi</Modal>);
+    await userEvent.keyboard('{Escape}');
+    expect(onDismiss).toHaveBeenCalledTimes(1);
+  });
+
+  it('dismisses on a backdrop click', async () => {
+    const onDismiss = vi.fn();
+    render(<Modal onDismiss={onDismiss}>hi</Modal>);
+    await userEvent.click(screen.getByRole('dialog'));
+    expect(onDismiss).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not dismiss when clicking inside the panel', async () => {
+    const onDismiss = vi.fn();
+    render(<Modal onDismiss={onDismiss}><button type="button">inside</button></Modal>);
+    await userEvent.click(screen.getByText('inside'));
+    expect(onDismiss).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/renderer/components/ui/Modal.tsx b/src/renderer/components/ui/Modal.tsx
new file mode 100644
index 0000000..9fdbfaf
--- /dev/null
+++ b/src/renderer/components/ui/Modal.tsx
@@ -0,0 +1,32 @@
+import { useEffect, type ReactNode } from 'react';
+
+export function Modal({
+  onDismiss,
+  className,
+  children,
+}: {
+  onDismiss: () => void;
+  className?: string;
+  children: ReactNode;
+}) {
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === 'Escape') onDismiss();
+    };
+    document.addEventListener('keydown', onKey);
+    return () => document.removeEventListener('keydown', onKey);
+  }, [onDismiss]);
+
+  return (
+    <div
+      className="fixed inset-0 z-10 flex items-center justify-center bg-black/30"
+      role="dialog"
+      aria-modal="true"
+      onMouseDown={(e) => {
+        if (e.target === e.currentTarget) onDismiss();
+      }}
+    >
+      <div className={className ?? 'rounded bg-white p-4 shadow-lg dark:bg-slate-900'}>{children}</div>
+    </div>
+  );
+}

From 12947c6b85b877eed9e24307a2e92a3c80f793cb Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 11:12:00 +0200
Subject: [PATCH 21/24] refactor(ui): adopt Modal in account/bucket/confirm
 dialogs

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/renderer/components/accounts/ExportAccountsDialog.tsx  | 7 +++----
 src/renderer/components/accounts/ImportAccountsDialog.tsx  | 7 +++----
 src/renderer/components/accounts/QuickAddAccountDialog.tsx | 7 +++----
 src/renderer/components/buckets/CreateBucketDialog.tsx     | 7 +++----
 src/renderer/components/ui/ConfirmDialog.test.tsx          | 7 +++++++
 src/renderer/components/ui/ConfirmDialog.tsx               | 7 +++----
 6 files changed, 22 insertions(+), 20 deletions(-)

diff --git a/src/renderer/components/accounts/ExportAccountsDialog.tsx b/src/renderer/components/accounts/ExportAccountsDialog.tsx
index c80acf2..a6606b8 100644
--- a/src/renderer/components/accounts/ExportAccountsDialog.tsx
+++ b/src/renderer/components/accounts/ExportAccountsDialog.tsx
@@ -3,6 +3,7 @@ import { useTranslation } from 'react-i18next';
 import { FiX } from 'react-icons/fi';
 import { useExportAccounts } from '../../hooks/useAccountTransfer';
 import { useToast } from '../ui/ToastProvider';
+import { Modal } from '../ui/Modal';
 
 export function ExportAccountsDialog({ accountIds, onClose }: { accountIds: string[]; onClose: () => void }) {
   const { t } = useTranslation();
@@ -34,8 +35,7 @@ export function ExportAccountsDialog({ accountIds, onClose }: { accountIds: stri
   const field = 'mt-1 w-full rounded border border-slate-300 px-2 py-1 text-sm dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100';
 
   return (
-    <div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">
-      <div className="w-[28rem] max-w-[90vw] rounded bg-white p-4 shadow-lg dark:bg-slate-900">
+    <Modal onDismiss={onClose} className="w-[28rem] max-w-[90vw] rounded bg-white p-4 shadow-lg dark:bg-slate-900">
         <div className="flex items-center justify-between pb-2">
           <p className="text-sm font-medium text-slate-800 dark:text-slate-100">{t('transfer.exportTitle')}</p>
           <button type="button" aria-label={t('common.close')} className="rounded px-2 hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onClose}>
@@ -81,7 +81,6 @@ export function ExportAccountsDialog({ accountIds, onClose }: { accountIds: stri
             </div>
           </>
         )}
-      </div>
-    </div>
+    </Modal>
   );
 }
diff --git a/src/renderer/components/accounts/ImportAccountsDialog.tsx b/src/renderer/components/accounts/ImportAccountsDialog.tsx
index c0e6ca9..5e31d91 100644
--- a/src/renderer/components/accounts/ImportAccountsDialog.tsx
+++ b/src/renderer/components/accounts/ImportAccountsDialog.tsx
@@ -6,6 +6,7 @@ import { useToast } from '../ui/ToastProvider';
 import { humanErrorMessage, errorCode } from '../../lib/result';
 import { UI_PROVIDERS } from '../../lib/providers';
 import type { ImportPreview } from '../../../main/accounts/accountTransfer';
+import { Modal } from '../ui/Modal';
 
 // TransferError codes → their localized message keys.
 const CODE_KEYS: Record<string, string> = {
@@ -90,8 +91,7 @@ export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => v
   const field = 'mt-1 w-full rounded border border-slate-300 px-2 py-1 text-sm dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100';
 
   return (
-    <div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">
-      <div className="w-[28rem] max-w-[90vw] rounded bg-white p-4 shadow-lg dark:bg-slate-900">
+    <Modal onDismiss={onClose} className="w-[28rem] max-w-[90vw] rounded bg-white p-4 shadow-lg dark:bg-slate-900">
         <div className="flex items-center justify-between pb-2">
           <p className="text-sm font-medium text-slate-800 dark:text-slate-100">{t('transfer.importTitle')}</p>
           <button type="button" aria-label={t('common.close')} className="rounded px-2 hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onClose}>
@@ -152,7 +152,6 @@ export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => v
             {t('transfer.import')}
           </button>
         </div>
-      </div>
-    </div>
+    </Modal>
   );
 }
diff --git a/src/renderer/components/accounts/QuickAddAccountDialog.tsx b/src/renderer/components/accounts/QuickAddAccountDialog.tsx
index e2485d2..c0386d5 100644
--- a/src/renderer/components/accounts/QuickAddAccountDialog.tsx
+++ b/src/renderer/components/accounts/QuickAddAccountDialog.tsx
@@ -4,6 +4,7 @@ import { useCreateAccount } from '../../hooks/useAccounts';
 import { useToast } from '../ui/ToastProvider';
 import { AccountForm } from './AccountForm';
 import type { Account } from '../../../main/storage/accountsRepo';
+import { Modal } from '../ui/Modal';
 
 export function QuickAddAccountDialog({
   onClose,
@@ -17,8 +18,7 @@ export function QuickAddAccountDialog({
   const { show } = useToast();
 
   return (
-    <div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">
-      <div className="max-h-[90vh] w-96 overflow-auto rounded bg-white p-4 shadow-lg dark:bg-slate-900">
+    <Modal onDismiss={onClose} className="max-h-[90vh] w-96 overflow-auto rounded bg-white p-4 shadow-lg dark:bg-slate-900">
         <div className="flex items-center justify-between pb-2">
           <p className="text-sm font-medium text-slate-800 dark:text-slate-100">{t('accounts.quickAddTitle')}</p>
           <button type="button" aria-label={t('common.close')} className="rounded px-2 hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onClose}>
@@ -38,7 +38,6 @@ export function QuickAddAccountDialog({
             }
           }}
         />
-      </div>
-    </div>
+    </Modal>
   );
 }
diff --git a/src/renderer/components/buckets/CreateBucketDialog.tsx b/src/renderer/components/buckets/CreateBucketDialog.tsx
index 4395b68..8bc2134 100644
--- a/src/renderer/components/buckets/CreateBucketDialog.tsx
+++ b/src/renderer/components/buckets/CreateBucketDialog.tsx
@@ -3,6 +3,7 @@ import { useTranslation } from 'react-i18next';
 import { FiX } from 'react-icons/fi';
 import { useCreateBucket } from '../../hooks/useCreateBucket';
 import { useToast } from '../ui/ToastProvider';
+import { Modal } from '../ui/Modal';
 
 export function isValidBucketName(name: string): boolean {
   if (!/^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/.test(name)) return false;
@@ -42,8 +43,7 @@ export function CreateBucketDialog({
   };
 
   return (
-    <div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">
-      <div className="w-96 rounded bg-white p-4 shadow-lg dark:bg-slate-900">
+    <Modal onDismiss={onClose} className="w-96 rounded bg-white p-4 shadow-lg dark:bg-slate-900">
         <div className="flex items-center justify-between pb-2">
           <p className="text-sm font-medium text-slate-800 dark:text-slate-100">{t('buckets.createTitle')}</p>
           <button type="button" aria-label={t('common.close')} className="rounded px-2 hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onClose}>
@@ -96,7 +96,6 @@ export function CreateBucketDialog({
             {t('buckets.create')}
           </button>
         </div>
-      </div>
-    </div>
+    </Modal>
   );
 }
diff --git a/src/renderer/components/ui/ConfirmDialog.test.tsx b/src/renderer/components/ui/ConfirmDialog.test.tsx
index 1783683..8e232d6 100644
--- a/src/renderer/components/ui/ConfirmDialog.test.tsx
+++ b/src/renderer/components/ui/ConfirmDialog.test.tsx
@@ -20,4 +20,11 @@ describe('ConfirmDialog', () => {
     await userEvent.click(screen.getByRole('button', { name: 'Cancel' }));
     expect(onCancel).toHaveBeenCalled();
   });
+
+  it('cancels on Escape', async () => {
+    const onCancel = vi.fn();
+    render(<ConfirmDialog message="Sure?" confirmLabel="Yes" onConfirm={() => {}} onCancel={onCancel} />);
+    await userEvent.keyboard('{Escape}');
+    expect(onCancel).toHaveBeenCalledTimes(1);
+  });
 });
diff --git a/src/renderer/components/ui/ConfirmDialog.tsx b/src/renderer/components/ui/ConfirmDialog.tsx
index 00fe88d..882783b 100644
--- a/src/renderer/components/ui/ConfirmDialog.tsx
+++ b/src/renderer/components/ui/ConfirmDialog.tsx
@@ -1,4 +1,5 @@
 import { useTranslation } from 'react-i18next';
+import { Modal } from './Modal';
 
 export function ConfirmDialog({
   message,
@@ -13,8 +14,7 @@ export function ConfirmDialog({
 }) {
   const { t } = useTranslation();
   return (
-    <div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">
-      <div className="w-80 rounded bg-white p-4 shadow-lg dark:bg-slate-900">
+    <Modal onDismiss={onCancel} className="w-80 rounded bg-white p-4 shadow-lg dark:bg-slate-900">
         <p className="text-sm text-slate-800 dark:text-slate-100">{message}</p>
         <div className="mt-4 flex justify-end gap-2">
           <button type="button" className="rounded px-3 py-1 text-sm hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onCancel}>
@@ -28,7 +28,6 @@ export function ConfirmDialog({
             {confirmLabel}
           </button>
         </div>
-      </div>
-    </div>
+    </Modal>
   );
 }

From 57a27daa28c62a0172185a041da8cf99af9294c1 Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 11:15:23 +0200
Subject: [PATCH 22/24] refactor(ui): adopt Modal in files/transfer dialogs

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/renderer/components/files/MetadataDialog.tsx    | 7 +++----
 src/renderer/components/files/PermissionsDialog.tsx | 7 +++----
 src/renderer/components/files/UploadLinkDialog.tsx  | 7 +++----
 src/renderer/components/transfer/MoveDialog.tsx     | 7 +++----
 src/renderer/components/transfer/NameDialog.tsx     | 6 +++---
 5 files changed, 15 insertions(+), 19 deletions(-)

diff --git a/src/renderer/components/files/MetadataDialog.tsx b/src/renderer/components/files/MetadataDialog.tsx
index deea47f..c739e1f 100644
--- a/src/renderer/components/files/MetadataDialog.tsx
+++ b/src/renderer/components/files/MetadataDialog.tsx
@@ -3,6 +3,7 @@ import { useTranslation } from 'react-i18next';
 import { FiX, FiTrash2 } from 'react-icons/fi';
 import { useObjectMetadataEditor } from '../../hooks/useObjectMetadataEditor';
 import { useToast } from '../ui/ToastProvider';
+import { Modal } from '../ui/Modal';
 
 interface Pair {
   key: string;
@@ -66,8 +67,7 @@ export function MetadataDialog({
   const field = 'mt-1 w-full rounded border border-slate-300 px-2 py-1 text-sm dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100';
 
   return (
-    <div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">
-      <div className="max-h-[80vh] w-[34rem] overflow-auto rounded bg-white p-4 shadow-lg dark:bg-slate-900">
+    <Modal onDismiss={onClose} className="max-h-[80vh] w-[34rem] overflow-auto rounded bg-white p-4 shadow-lg dark:bg-slate-900">
         <div className="flex items-center justify-between pb-2">
           <p className="text-sm font-medium text-slate-800 dark:text-slate-100">{t('files.metadataDialog.title')}</p>
           <button type="button" aria-label={t('common.close')} className="rounded px-2 hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onClose}><FiX className="h-4 w-4" aria-hidden /></button>
@@ -143,7 +143,6 @@ export function MetadataDialog({
             </div>
           </>
         )}
-      </div>
-    </div>
+    </Modal>
   );
 }
diff --git a/src/renderer/components/files/PermissionsDialog.tsx b/src/renderer/components/files/PermissionsDialog.tsx
index 3261fd7..1a28a13 100644
--- a/src/renderer/components/files/PermissionsDialog.tsx
+++ b/src/renderer/components/files/PermissionsDialog.tsx
@@ -4,6 +4,7 @@ import { FiX, FiTrash2 } from 'react-icons/fi';
 import { useObjectAcl } from '../../hooks/useObjectAcl';
 import { useToast } from '../ui/ToastProvider';
 import type { AclGrant, AclPermission } from '../../../main/s3/objectAcl';
+import { Modal } from '../ui/Modal';
 
 const PERMISSIONS: AclPermission[] = ['FULL_CONTROL', 'WRITE', 'WRITE_ACP', 'READ', 'READ_ACP'];
 const GROUP_URIS = {
@@ -71,8 +72,7 @@ export function PermissionsDialog({
   };
 
   return (
-    <div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">
-      <div className="max-h-[80vh] w-[34rem] overflow-auto rounded bg-white p-4 shadow-lg dark:bg-slate-900">
+    <Modal onDismiss={onClose} className="max-h-[80vh] w-[34rem] overflow-auto rounded bg-white p-4 shadow-lg dark:bg-slate-900">
         <div className="flex items-center justify-between pb-2">
           <p className="text-sm font-medium text-slate-800 dark:text-slate-100">{t('files.permissions.title')}</p>
           <button type="button" aria-label={t('common.close')} className="rounded px-2 hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onClose}><FiX className="h-4 w-4" aria-hidden /></button>
@@ -166,7 +166,6 @@ export function PermissionsDialog({
             </div>
           </>
         )}
-      </div>
-    </div>
+    </Modal>
   );
 }
diff --git a/src/renderer/components/files/UploadLinkDialog.tsx b/src/renderer/components/files/UploadLinkDialog.tsx
index 4c11312..1b48098 100644
--- a/src/renderer/components/files/UploadLinkDialog.tsx
+++ b/src/renderer/components/files/UploadLinkDialog.tsx
@@ -2,6 +2,7 @@ import { useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { FiX } from 'react-icons/fi';
 import { useToast } from '../ui/ToastProvider';
+import { Modal } from '../ui/Modal';
 
 export function UploadLinkDialog({
   accountId,
@@ -47,8 +48,7 @@ export function UploadLinkDialog({
   };
 
   return (
-    <div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">
-      <div className="w-[28rem] rounded bg-white p-4 shadow-lg dark:bg-slate-900">
+    <Modal onDismiss={onClose} className="w-[28rem] rounded bg-white p-4 shadow-lg dark:bg-slate-900">
         <div className="flex items-center justify-between pb-2">
           <p className="text-sm font-medium text-slate-800 dark:text-slate-100">{t('files.uploadLink.title')}</p>
           <button type="button" aria-label={t('common.close')} className="rounded px-2 hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onClose}><FiX className="h-4 w-4" aria-hidden /></button>
@@ -103,7 +103,6 @@ export function UploadLinkDialog({
             </button>
           </div>
         )}
-      </div>
-    </div>
+    </Modal>
   );
 }
diff --git a/src/renderer/components/transfer/MoveDialog.tsx b/src/renderer/components/transfer/MoveDialog.tsx
index b582c95..ce5d4fb 100644
--- a/src/renderer/components/transfer/MoveDialog.tsx
+++ b/src/renderer/components/transfer/MoveDialog.tsx
@@ -3,6 +3,7 @@ import { useTranslation } from 'react-i18next';
 import { useTransfer } from '../../hooks/useTransfer';
 import { useToast } from '../ui/ToastProvider';
 import { FolderPicker } from './FolderPicker';
+import { Modal } from '../ui/Modal';
 
 export type MoveItem =
   | { kind: 'file'; name: string; parent: string; key: string }
@@ -49,8 +50,7 @@ export function MoveDialog({
   };
 
   return (
-    <div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">
-      <div className="w-96 rounded bg-white p-4 shadow-lg dark:bg-slate-900">
+    <Modal onDismiss={onClose} className="w-96 rounded bg-white p-4 shadow-lg dark:bg-slate-900">
         <div className="flex items-center justify-between pb-2">
           <p className="text-sm font-medium text-slate-800 dark:text-slate-100">{t('transfer.moveTitle', { name: item.name })}</p>
           <button type="button" aria-label={t('common.cancel')} className="rounded px-2 hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onClose}>
@@ -58,7 +58,6 @@ export function MoveDialog({
           </button>
         </div>
         <FolderPicker accountId={accountId} bucket={bucket} canPick={canPick} onPick={onPick} />
-      </div>
-    </div>
+    </Modal>
   );
 }
diff --git a/src/renderer/components/transfer/NameDialog.tsx b/src/renderer/components/transfer/NameDialog.tsx
index d8ea621..c43d3a9 100644
--- a/src/renderer/components/transfer/NameDialog.tsx
+++ b/src/renderer/components/transfer/NameDialog.tsx
@@ -1,5 +1,6 @@
 import { useState } from 'react';
 import { useTranslation } from 'react-i18next';
+import { Modal } from '../ui/Modal';
 
 export function NameDialog({
   title,
@@ -20,9 +21,8 @@ export function NameDialog({
   const valid = trimmed !== '' && !trimmed.includes('/');
 
   return (
-    <div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">
+    <Modal onDismiss={onCancel} className="w-80 rounded bg-white p-4 shadow-lg dark:bg-slate-900">
       <form
-        className="w-80 rounded bg-white p-4 shadow-lg dark:bg-slate-900"
         onSubmit={(e) => {
           e.preventDefault();
           if (valid) onConfirm(trimmed);
@@ -51,6 +51,6 @@ export function NameDialog({
           </button>
         </div>
       </form>
-    </div>
+    </Modal>
   );
 }

From ebe6ef5fbcb3147c84d342763d1b371e8ef99bf4 Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 11:23:55 +0200
Subject: [PATCH 23/24] feat(accounts): warn and choose skip/copy/replace on
 name collisions

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../accounts/ImportAccountsDialog.test.tsx    | 28 +++++++++++++-
 .../accounts/ImportAccountsDialog.tsx         | 37 ++++++++++++++++++-
 src/renderer/i18n/locales/de.json             |  8 +++-
 src/renderer/i18n/locales/en.json             |  8 +++-
 src/renderer/i18n/locales/fr.json             |  8 +++-
 src/renderer/i18n/locales/nl.json             |  8 +++-
 src/renderer/i18n/locales/pl.json             |  8 +++-
 src/renderer/i18n/locales/ro.json             |  8 +++-
 8 files changed, 103 insertions(+), 10 deletions(-)

diff --git a/src/renderer/components/accounts/ImportAccountsDialog.test.tsx b/src/renderer/components/accounts/ImportAccountsDialog.test.tsx
index 69d0354..22cde84 100644
--- a/src/renderer/components/accounts/ImportAccountsDialog.test.tsx
+++ b/src/renderer/components/accounts/ImportAccountsDialog.test.tsx
@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { render, screen } from '@testing-library/react';
+import { render, screen, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import type { ReactNode } from 'react';
@@ -20,6 +20,7 @@ function setS3(over: Record<string, unknown> = {}) {
     accounts: {
       import: vi.fn().mockResolvedValue({ ok: true, data: [{ id: 'n1' }] }),
       importPreview: vi.fn().mockResolvedValue({ ok: true, data: { encrypted: false, accounts: [{ label: 'AWS prod', provider: 'amazon-s3' }] } }),
+      list: vi.fn().mockResolvedValue({ ok: true, data: [] }),
       ...over,
     },
     openTextFile: vi.fn().mockResolvedValue({ ok: true, data: 'FILE-BLOB' }),
@@ -45,7 +46,7 @@ describe('ImportAccountsDialog', () => {
     await screen.findByText('AWS prod (Amazon S3)');
     await userEvent.click(screen.getByRole('button', { name: 'Import' }));
     await screen.findByText('AWS prod (Amazon S3)');
-    expect(window.s3.accounts.import).toHaveBeenCalledWith({ blob: 'BLOB', password: undefined });
+    expect(window.s3.accounts.import).toHaveBeenCalledWith({ blob: 'BLOB', password: undefined, onDuplicate: 'copy' });
     expect(onImported).toHaveBeenCalled();
     expect(onClose).toHaveBeenCalled();
   });
@@ -88,4 +89,27 @@ describe('ImportAccountsDialog', () => {
     await userEvent.click(screen.getByRole('button', { name: 'Load file' }));
     expect(await screen.findByDisplayValue('FILE-BLOB')).toBeInTheDocument();
   });
+
+  it('warns about a name collision and imports with the chosen mode', async () => {
+    setS3({
+      list: vi.fn().mockResolvedValue({ ok: true, data: [{ id: 'x', label: 'AWS prod', provider: 'amazon-s3', region: 'r', accessKeyId: 'K', createdAt: 1 }] }),
+    });
+    const onImported = vi.fn();
+    wrap(<ImportAccountsDialog onClose={() => {}} onImported={onImported} />);
+    await userEvent.type(screen.getByLabelText('Import data'), 'BLOB');
+    expect(await screen.findByText('1 names already exist')).toBeInTheDocument();
+    await userEvent.selectOptions(screen.getByLabelText('Existing names'), 'replace');
+    await userEvent.click(screen.getByRole('button', { name: 'Import' }));
+    await waitFor(() => expect(window.s3.accounts.import).toHaveBeenCalledWith({ blob: 'BLOB', password: undefined, onDuplicate: 'replace' }));
+    expect(onImported).toHaveBeenCalled();
+  });
+
+  it('imports with copy mode when there is no collision', async () => {
+    wrap(<ImportAccountsDialog onClose={() => {}} onImported={() => {}} />);
+    await userEvent.type(screen.getByLabelText('Import data'), 'BLOB');
+    await screen.findByText('AWS prod (Amazon S3)');
+    expect(screen.queryByLabelText('Existing names')).not.toBeInTheDocument();
+    await userEvent.click(screen.getByRole('button', { name: 'Import' }));
+    await waitFor(() => expect(window.s3.accounts.import).toHaveBeenCalledWith({ blob: 'BLOB', password: undefined, onDuplicate: 'copy' }));
+  });
 });
diff --git a/src/renderer/components/accounts/ImportAccountsDialog.tsx b/src/renderer/components/accounts/ImportAccountsDialog.tsx
index 5e31d91..08b9d8f 100644
--- a/src/renderer/components/accounts/ImportAccountsDialog.tsx
+++ b/src/renderer/components/accounts/ImportAccountsDialog.tsx
@@ -2,6 +2,7 @@ import { useEffect, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { FiX } from 'react-icons/fi';
 import { useImportAccounts, useImportPreview } from '../../hooks/useAccountTransfer';
+import { useAccounts } from '../../hooks/useAccounts';
 import { useToast } from '../ui/ToastProvider';
 import { humanErrorMessage, errorCode } from '../../lib/result';
 import { UI_PROVIDERS } from '../../lib/providers';
@@ -31,6 +32,8 @@ export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => v
   const [checking, setChecking] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const reqId = useRef(0);
+  const existingAccounts = useAccounts();
+  const [duplicateMode, setDuplicateMode] = useState<'skip' | 'copy' | 'replace'>('skip');
 
   // Background, debounced preview whenever the blob or password changes.
   useEffect(() => {
@@ -77,7 +80,11 @@ export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => v
   const onImport = async () => {
     setError(null);
     try {
-      const created = await importAccounts.mutateAsync({ blob, password: password || undefined });
+      const created = await importAccounts.mutateAsync({
+        blob,
+        password: password || undefined,
+        onDuplicate: collisions.length > 0 ? duplicateMode : 'copy',
+      });
       show(t('transfer.imported', { count: created.length }));
       onImported();
       onClose();
@@ -88,6 +95,8 @@ export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => v
   };
 
   const accounts = preview?.accounts ?? null;
+  const existingLabels = new Set((existingAccounts.data ?? []).map((a) => a.label));
+  const collisions = accounts?.filter((a) => existingLabels.has(a.label)) ?? [];
   const field = 'mt-1 w-full rounded border border-slate-300 px-2 py-1 text-sm dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100';
 
   return (
@@ -130,13 +139,37 @@ export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => v
               <p className="text-slate-700 dark:text-slate-200">{t('transfer.previewCount', { count: accounts.length })}</p>
               <ul className="mt-1 max-h-32 overflow-auto text-slate-600 dark:text-slate-300">
                 {accounts.map((a, i) => (
-                  <li key={i}>{a.label} ({providerLabel(a.provider)})</li>
+                  <li key={i}>
+                    {a.label} ({providerLabel(a.provider)})
+                    {existingLabels.has(a.label) && (
+                      <span className="ml-1 text-amber-600 dark:text-amber-400">— {t('transfer.nameExists')}</span>
+                    )}
+                  </li>
                 ))}
               </ul>
             </div>
           )}
         </div>
 
+        {collisions.length > 0 && (
+          <div className="mt-2">
+            <p className="text-xs text-amber-600 dark:text-amber-400">{t('transfer.duplicateWarning', { count: collisions.length })}</p>
+            <label className="mt-1 block text-sm">
+              {t('transfer.duplicateMode')}
+              <select
+                aria-label={t('transfer.duplicateMode')}
+                className="mt-1 block w-full rounded border border-slate-300 px-2 py-1 text-sm dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100"
+                value={duplicateMode}
+                onChange={(e) => setDuplicateMode(e.target.value as 'skip' | 'copy' | 'replace')}
+              >
+                <option value="skip">{t('transfer.duplicateSkip')}</option>
+                <option value="copy">{t('transfer.duplicateCopy')}</option>
+                <option value="replace">{t('transfer.duplicateReplace')}</option>
+              </select>
+            </label>
+          </div>
+        )}
+
         {error !== null && <p className="mt-2 text-xs text-red-600 dark:text-red-400">{error}</p>}
 
         <div className="mt-4 flex justify-end gap-2">
diff --git a/src/renderer/i18n/locales/de.json b/src/renderer/i18n/locales/de.json
index 8f9b188..4a51509 100644
--- a/src/renderer/i18n/locales/de.json
+++ b/src/renderer/i18n/locales/de.json
@@ -350,7 +350,13 @@
     "exportAria": "{{label}} exportieren",
     "previewCount": "{{count}} Konten werden importiert",
     "encryptedHint": "Verschlüsselt — Passwort zur Vorschau eingeben",
-    "checking": "Wird geprüft…"
+    "checking": "Wird geprüft…",
+    "duplicateWarning": "{{count}} Namen existieren bereits",
+    "duplicateMode": "Vorhandene Namen",
+    "duplicateSkip": "Überspringen",
+    "duplicateCopy": "Als Kopie importieren",
+    "duplicateReplace": "Vorhandene ersetzen",
+    "nameExists": "Name existiert"
   },
   "dashboard": {
     "title": "Dashboard",
diff --git a/src/renderer/i18n/locales/en.json b/src/renderer/i18n/locales/en.json
index 5c495ee..a311bb6 100644
--- a/src/renderer/i18n/locales/en.json
+++ b/src/renderer/i18n/locales/en.json
@@ -350,7 +350,13 @@
     "exportAria": "Export {{label}}",
     "previewCount": "{{count}} accounts will be imported",
     "encryptedHint": "Encrypted — enter the password to preview",
-    "checking": "Checking…"
+    "checking": "Checking…",
+    "duplicateWarning": "{{count}} names already exist",
+    "duplicateMode": "Existing names",
+    "duplicateSkip": "Skip",
+    "duplicateCopy": "Import as copies",
+    "duplicateReplace": "Replace existing",
+    "nameExists": "name exists"
   },
   "dashboard": {
     "title": "Dashboard",
diff --git a/src/renderer/i18n/locales/fr.json b/src/renderer/i18n/locales/fr.json
index 7ed47fd..f693142 100644
--- a/src/renderer/i18n/locales/fr.json
+++ b/src/renderer/i18n/locales/fr.json
@@ -350,7 +350,13 @@
     "exportAria": "Exporter {{label}}",
     "previewCount": "{{count}} comptes seront importés",
     "encryptedHint": "Chiffré — saisissez le mot de passe pour prévisualiser",
-    "checking": "Vérification…"
+    "checking": "Vérification…",
+    "duplicateWarning": "{{count}} noms existent déjà",
+    "duplicateMode": "Noms existants",
+    "duplicateSkip": "Ignorer",
+    "duplicateCopy": "Importer comme copies",
+    "duplicateReplace": "Remplacer l'existant",
+    "nameExists": "nom existant"
   },
   "dashboard": {
     "title": "Tableau de bord",
diff --git a/src/renderer/i18n/locales/nl.json b/src/renderer/i18n/locales/nl.json
index 2bc8d62..49b4e4f 100644
--- a/src/renderer/i18n/locales/nl.json
+++ b/src/renderer/i18n/locales/nl.json
@@ -350,7 +350,13 @@
     "exportAria": "{{label}} exporteren",
     "previewCount": "{{count}} accounts worden geïmporteerd",
     "encryptedHint": "Versleuteld — voer het wachtwoord in voor een voorbeeld",
-    "checking": "Controleren…"
+    "checking": "Controleren…",
+    "duplicateWarning": "{{count}} namen bestaan al",
+    "duplicateMode": "Bestaande namen",
+    "duplicateSkip": "Overslaan",
+    "duplicateCopy": "Als kopie importeren",
+    "duplicateReplace": "Bestaande vervangen",
+    "nameExists": "naam bestaat"
   },
   "dashboard": {
     "title": "Dashboard",
diff --git a/src/renderer/i18n/locales/pl.json b/src/renderer/i18n/locales/pl.json
index a572fbe..8c3e145 100644
--- a/src/renderer/i18n/locales/pl.json
+++ b/src/renderer/i18n/locales/pl.json
@@ -354,7 +354,13 @@
     "exportAria": "Eksportuj {{label}}",
     "previewCount": "Zostanie zaimportowanych {{count}} kont",
     "encryptedHint": "Zaszyfrowane — wprowadź hasło, aby wyświetlić podgląd",
-    "checking": "Sprawdzanie…"
+    "checking": "Sprawdzanie…",
+    "duplicateWarning": "{{count}} nazw już istnieje",
+    "duplicateMode": "Istniejące nazwy",
+    "duplicateSkip": "Pomiń",
+    "duplicateCopy": "Importuj jako kopie",
+    "duplicateReplace": "Zastąp istniejące",
+    "nameExists": "nazwa istnieje"
   },
   "dashboard": {
     "title": "Pulpit",
diff --git a/src/renderer/i18n/locales/ro.json b/src/renderer/i18n/locales/ro.json
index 66c70fd..92df520 100644
--- a/src/renderer/i18n/locales/ro.json
+++ b/src/renderer/i18n/locales/ro.json
@@ -352,7 +352,13 @@
     "exportAria": "Exportă {{label}}",
     "previewCount": "{{count}} conturi vor fi importate",
     "encryptedHint": "Criptat — introdu parola pentru previzualizare",
-    "checking": "Se verifică…"
+    "checking": "Se verifică…",
+    "duplicateWarning": "{{count}} nume există deja",
+    "duplicateMode": "Nume existente",
+    "duplicateSkip": "Omite",
+    "duplicateCopy": "Importă drept copii",
+    "duplicateReplace": "Înlocuiește existentele",
+    "nameExists": "numele există"
   },
   "dashboard": {
     "title": "Tablou de bord",

From c89342dc47a93d832c7312ce01faf37cb477b0bc Mon Sep 17 00:00:00 2001
From: noidee <hello@noidee.dev>
Date: Tue, 16 Jun 2026 11:30:21 +0200
Subject: [PATCH 24/24] docs(accounts): add account-transfer design specs and
 plans

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../plans/2026-06-16-account-transfer.md      | 1195 +++++++++++++++++
 .../plans/2026-06-16-duplicate-and-modal.md   |  534 ++++++++
 .../2026-06-16-transfer-dialog-refinements.md |  743 ++++++++++
 .../2026-06-16-account-transfer-design.md     |  165 +++
 .../2026-06-16-duplicate-and-modal-design.md  |  135 ++
 ...6-16-transfer-dialog-refinements-design.md |  124 ++
 6 files changed, 2896 insertions(+)
 create mode 100644 docs/superpowers/plans/2026-06-16-account-transfer.md
 create mode 100644 docs/superpowers/plans/2026-06-16-duplicate-and-modal.md
 create mode 100644 docs/superpowers/plans/2026-06-16-transfer-dialog-refinements.md
 create mode 100644 docs/superpowers/specs/2026-06-16-account-transfer-design.md
 create mode 100644 docs/superpowers/specs/2026-06-16-duplicate-and-modal-design.md
 create mode 100644 docs/superpowers/specs/2026-06-16-transfer-dialog-refinements-design.md

diff --git a/docs/superpowers/plans/2026-06-16-account-transfer.md b/docs/superpowers/plans/2026-06-16-account-transfer.md
new file mode 100644
index 0000000..5eba414
--- /dev/null
+++ b/docs/superpowers/plans/2026-06-16-account-transfer.md
@@ -0,0 +1,1195 @@
+# Account Import / Export Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Export one/several/all accounts (incl. their secret keys) to an optionally password-encrypted string with copy/download, and import accounts from a pasted string or a loaded file.
+
+**Architecture:** A pure `node:crypto` module handles serialize/encrypt/decrypt (scrypt + AES-256-GCM). IPC handlers glue it to the accounts/secrets repos; two injected main helpers do file save/open. The renderer adds two dialogs and entry points in the Accounts screen.
+
+**Tech Stack:** Electron Forge, TypeScript, `node:crypto` (no new dependency), TanStack Query, react-i18next (6 locales), Vitest + Testing Library.
+
+**Spec:** `docs/superpowers/specs/2026-06-16-account-transfer-design.md`
+
+**Conventions:**
+- `Result<T>` via `ok(data)`/`err(code, message)` (`src/main/shared/result.ts`); renderer `unwrap()` (`src/renderer/lib/result.ts`) throws on error.
+- Handlers registered with `h(CH.x, fn)` (try/catch → `toErr`). Deps injected via `RegisterDeps`; `main.ts` wires real impls.
+- Tests load real i18n in English. Single file: `npx vitest run <path>`. Full: `npm test`. Lint: `npm run lint`. Types: `npx tsc --noEmit`.
+- Conventional Commits, footer `Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>`. No pushing. Branch: `feat/account-import-export`.
+
+---
+
+### Task 1: Pure `accountTransfer` module
+
+**Files:**
+- Create: `src/main/accounts/accountTransfer.ts`
+- Test: `src/main/accounts/accountTransfer.test.ts`
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `src/main/accounts/accountTransfer.test.ts`:
+
+```ts
+import { describe, it, expect } from 'vitest';
+import { exportAccounts, importAccounts, TransferError, type ExportAccount } from './accountTransfer';
+
+const acc: ExportAccount = {
+  label: 'AWS prod', provider: 'amazon-s3', region: 'eu-central-1',
+  accessKeyId: 'AK', secretAccessKey: 'SECRET',
+};
+const custom: ExportAccount = {
+  label: 'MinIO', provider: 'custom', region: 'us-east-1',
+  accessKeyId: 'CK', secretAccessKey: 'CS', endpoint: 'https://minio.example.com', forcePathStyle: true,
+};
+
+describe('accountTransfer round-trip', () => {
+  it('exports and imports without a password (unencrypted)', () => {
+    const blob = exportAccounts([acc]);
+    expect(importAccounts(blob)).toEqual([acc]);
+  });
+
+  it('exports and imports with a password', () => {
+    const blob = exportAccounts([acc, custom], 'hunter2');
+    expect(importAccounts(blob, 'hunter2')).toEqual([acc, custom]);
+  });
+
+  it('produces different ciphertext each time (random salt/iv)', () => {
+    expect(exportAccounts([acc], 'pw')).not.toEqual(exportAccounts([acc], 'pw'));
+  });
+});
+
+describe('accountTransfer errors', () => {
+  it('throws IncorrectPassword for a wrong password', () => {
+    const blob = exportAccounts([acc], 'right');
+    expect(() => importAccounts(blob, 'wrong')).toThrow(expect.objectContaining({ code: 'IncorrectPassword' }));
+  });
+
+  it('throws PasswordRequired when an encrypted blob is imported without a password', () => {
+    const blob = exportAccounts([acc], 'pw');
+    expect(() => importAccounts(blob)).toThrow(expect.objectContaining({ code: 'PasswordRequired' }));
+  });
+
+  it('throws InvalidData for non-base64 / non-JSON garbage', () => {
+    expect(() => importAccounts('!!!not-base64!!!')).toThrow(expect.objectContaining({ code: 'InvalidData' }));
+  });
+
+  it('throws InvalidData for a JSON blob that is not our format', () => {
+    const notOurs = Buffer.from(JSON.stringify({ hello: 'world' }), 'utf8').toString('base64');
+    expect(() => importAccounts(notOurs)).toThrow(expect.objectContaining({ code: 'InvalidData' }));
+  });
+
+  it('throws IncorrectPassword when the ciphertext is tampered', () => {
+    const blob = exportAccounts([acc], 'pw');
+    const env = JSON.parse(Buffer.from(blob, 'base64').toString('utf8'));
+    env.data = Buffer.from('tampered-ciphertext').toString('base64');
+    const tampered = Buffer.from(JSON.stringify(env), 'utf8').toString('base64');
+    expect(() => importAccounts(tampered, 'pw')).toThrow(expect.objectContaining({ code: 'IncorrectPassword' }));
+  });
+
+  it('exposes TransferError with a code', () => {
+    expect(new TransferError('InvalidData', 'x').code).toBe('InvalidData');
+  });
+});
+```
+
+- [ ] **Step 2: Run to verify failure**
+
+Run: `npx vitest run src/main/accounts/accountTransfer.test.ts`
+Expected: FAIL — cannot resolve `./accountTransfer`.
+
+- [ ] **Step 3: Implement the module**
+
+Create `src/main/accounts/accountTransfer.ts`:
+
+```ts
+import { randomBytes, scryptSync, createCipheriv, createDecipheriv } from 'node:crypto';
+import type { ProviderId } from '../s3/providers';
+
+export interface ExportAccount {
+  label: string;
+  provider: ProviderId;
+  region: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  endpoint?: string;
+  forcePathStyle?: boolean;
+}
+
+export type TransferErrorCode = 'PasswordRequired' | 'IncorrectPassword' | 'InvalidData';
+
+export class TransferError extends Error {
+  constructor(public readonly code: TransferErrorCode, message: string) {
+    super(message);
+    this.name = 'TransferError';
+  }
+}
+
+const FORMAT = 's3manager-accounts';
+const VERSION = 1;
+const SCRYPT = { N: 32768, r: 8, p: 1 };
+const KEYLEN = 32;
+
+function deriveKey(password: string, salt: Buffer): Buffer {
+  return scryptSync(password, salt, KEYLEN, { N: SCRYPT.N, r: SCRYPT.r, p: SCRYPT.p });
+}
+
+export function exportAccounts(accounts: ExportAccount[], password?: string): string {
+  const payload = JSON.stringify({ accounts });
+  let envelope: Record<string, unknown>;
+  if (password && password.length > 0) {
+    const salt = randomBytes(16);
+    const iv = randomBytes(12);
+    const cipher = createCipheriv('aes-256-gcm', deriveKey(password, salt), iv);
+    const ciphertext = Buffer.concat([cipher.update(payload, 'utf8'), cipher.final()]);
+    envelope = {
+      format: FORMAT,
+      version: VERSION,
+      encrypted: true,
+      kdf: { name: 'scrypt', N: SCRYPT.N, r: SCRYPT.r, p: SCRYPT.p, salt: salt.toString('base64') },
+      cipher: 'aes-256-gcm',
+      iv: iv.toString('base64'),
+      tag: cipher.getAuthTag().toString('base64'),
+      data: ciphertext.toString('base64'),
+    };
+  } else {
+    envelope = { format: FORMAT, version: VERSION, encrypted: false, data: payload };
+  }
+  return Buffer.from(JSON.stringify(envelope), 'utf8').toString('base64');
+}
+
+export function importAccounts(blob: string, password?: string): ExportAccount[] {
+  let env: Record<string, unknown>;
+  try {
+    const json = Buffer.from(blob.trim(), 'base64').toString('utf8');
+    const parsed: unknown = JSON.parse(json);
+    if (typeof parsed !== 'object' || parsed === null) throw new Error('not an object');
+    env = parsed as Record<string, unknown>;
+  } catch {
+    throw new TransferError('InvalidData', 'The import data is not valid.');
+  }
+  if (env.format !== FORMAT || env.version !== VERSION || typeof env.data !== 'string') {
+    throw new TransferError('InvalidData', 'The import data is not a recognized account export.');
+  }
+
+  let payload: string;
+  if (env.encrypted === true) {
+    if (!password || password.length === 0) {
+      throw new TransferError('PasswordRequired', 'This export is password-protected.');
+    }
+    try {
+      const kdf = env.kdf as { salt: string };
+      const salt = Buffer.from(kdf.salt, 'base64');
+      const iv = Buffer.from(env.iv as string, 'base64');
+      const tag = Buffer.from(env.tag as string, 'base64');
+      const decipher = createDecipheriv('aes-256-gcm', deriveKey(password, salt), iv);
+      decipher.setAuthTag(tag);
+      payload = Buffer.concat([
+        decipher.update(Buffer.from(env.data as string, 'base64')),
+        decipher.final(),
+      ]).toString('utf8');
+    } catch {
+      throw new TransferError('IncorrectPassword', 'Incorrect password or corrupted data.');
+    }
+  } else {
+    payload = env.data;
+  }
+
+  let parsedPayload: unknown;
+  try {
+    parsedPayload = JSON.parse(payload);
+  } catch {
+    throw new TransferError('InvalidData', 'The import payload is malformed.');
+  }
+  const accounts = (parsedPayload as { accounts?: unknown }).accounts;
+  if (!Array.isArray(accounts)) {
+    throw new TransferError('InvalidData', 'The import payload has no accounts.');
+  }
+  return accounts as ExportAccount[];
+}
+```
+
+- [ ] **Step 4: Run to verify pass**
+
+Run: `npx vitest run src/main/accounts/accountTransfer.test.ts`
+Expected: PASS (10 tests).
+
+- [ ] **Step 5: Lint + commit**
+
+Run: `npm run lint` (0 errors), then:
+
+```bash
+git add src/main/accounts/accountTransfer.ts src/main/accounts/accountTransfer.test.ts
+git commit -m "feat(accounts): add encrypted account export/import module" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 2: Main file helpers — `saveTextFile` / `openTextFile`
+
+**Files:**
+- Modify: `src/main/ipc/channels.ts`, `src/main/ipc/register.ts`, `src/main.ts`, `src/preload.ts`, `src/main/ipc/register.test.ts`
+
+- [ ] **Step 1: Add the failing handler tests**
+
+In `src/main/ipc/register.test.ts`, add inside `describe('registerIpc', …)`:
+
+```ts
+  it('util:saveTextFile delegates to the injected saveTextFile helper', async () => {
+    const saveTextFile = vi.fn().mockResolvedValue(true);
+    const { handlers } = buildHarness({ saveTextFile });
+    const res = (await handlers.get(CH.saveTextFile)!({ defaultName: 'x.txt', contents: 'hi' })) as { ok: boolean; data: { saved: boolean } };
+    expect(saveTextFile).toHaveBeenCalledWith('x.txt', 'hi');
+    expect(res).toEqual({ ok: true, data: { saved: true } });
+  });
+
+  it('util:openTextFile delegates to the injected openTextFile helper', async () => {
+    const openTextFile = vi.fn().mockResolvedValue('file-contents');
+    const { handlers } = buildHarness({ openTextFile });
+    const res = (await handlers.get(CH.openTextFile)!()) as { ok: boolean; data: string | null };
+    expect(res).toEqual({ ok: true, data: 'file-contents' });
+  });
+```
+
+(`buildHarness({ overrides })` already spreads overrides into deps — added in the update-check work. If this branch lacks it, change `function buildHarness()` to `function buildHarness(overrides: Record<string, unknown> = {})` and spread `...overrides` into the deps object.)
+
+- [ ] **Step 2: Run to verify failure**
+
+Run: `npx vitest run src/main/ipc/register.test.ts`
+Expected: FAIL — `CH.saveTextFile`/`CH.openTextFile` undefined.
+
+- [ ] **Step 3: Add channels (`channels.ts`)**
+
+In the `CH` object, after `openExternal: 'shell:openExternal',`:
+
+```ts
+  saveTextFile: 'util:saveTextFile',
+  openTextFile: 'util:openTextFile',
+```
+
+In `ApiMap`, after the `[CH.openExternal]` line:
+
+```ts
+  [CH.saveTextFile]: { args: [{ defaultName: string; contents: string }]; res: Result<{ saved: boolean }> };
+  [CH.openTextFile]: { args: []; res: Result<string | null> };
+```
+
+- [ ] **Step 4: Add deps + handlers (`register.ts`)**
+
+In `RegisterDeps`, after the `selectDirectory` field:
+
+```ts
+  /** Saves text to a user-chosen file; resolves true if saved, false if cancelled. Injected by main.ts. */
+  saveTextFile: (defaultName: string, contents: string) => Promise<boolean>;
+  /** Opens a user-chosen text file and resolves its contents, or null if cancelled. Injected by main.ts. */
+  openTextFile: () => Promise<string | null>;
+```
+
+After the `h(CH.getAppInfo, …)` block (before the closing `}` of `registerIpc`):
+
+```ts
+  h(CH.saveTextFile, async (a: { defaultName: string; contents: string }) => {
+    const saved = await deps.saveTextFile(a.defaultName, a.contents);
+    return ok({ saved });
+  });
+
+  h(CH.openTextFile, async () => ok(await deps.openTextFile()));
+```
+
+- [ ] **Step 5: Wire real impls (`main.ts`)**
+
+Add to the imports at the top: change `import path from 'node:path';` group by adding below it:
+
+```ts
+import { readFile, writeFile } from 'node:fs/promises';
+```
+
+In `initBackend`, after the `selectDirectory` const block, add:
+
+```ts
+  const saveTextFile = async (defaultName: string, contents: string): Promise<boolean> => {
+    const win = BrowserWindow.getFocusedWindow();
+    const result = win
+      ? await dialog.showSaveDialog(win, { defaultPath: defaultName })
+      : await dialog.showSaveDialog({ defaultPath: defaultName });
+    if (result.canceled || !result.filePath) return false;
+    await writeFile(result.filePath, contents, 'utf8');
+    return true;
+  };
+  const openTextFile = async (): Promise<string | null> => {
+    const win = BrowserWindow.getFocusedWindow();
+    const result = win
+      ? await dialog.showOpenDialog(win, { properties: ['openFile'] })
+      : await dialog.showOpenDialog({ properties: ['openFile'] });
+    if (result.canceled || !result.filePaths[0]) return null;
+    return readFile(result.filePaths[0], 'utf8');
+  };
+```
+
+In the `registerIpc(ipcMain, { … })` call, add `saveTextFile, openTextFile,` to the deps object.
+
+- [ ] **Step 6: Expose in preload (`preload.ts`)**
+
+After the `openExternal` line:
+
+```ts
+  saveTextFile: (a: ApiMap[typeof CH.saveTextFile]['args'][0]) => invoke(CH.saveTextFile, a),
+  openTextFile: () => invoke(CH.openTextFile),
+```
+
+- [ ] **Step 7: Run to verify pass + types + lint**
+
+Run: `npx vitest run src/main/ipc/register.test.ts` (pass, incl. the every-channel loop).
+Run: `npx tsc --noEmit` (clean), `npm run lint` (0 errors).
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add src/main/ipc/channels.ts src/main/ipc/register.ts src/main.ts src/preload.ts src/main/ipc/register.test.ts
+git commit -m "feat(ipc): add saveTextFile/openTextFile helpers" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 3: IPC — `accountsExport` / `accountsImport`
+
+**Files:**
+- Modify: `src/main/ipc/channels.ts`, `src/main/ipc/register.ts`, `src/preload.ts`, `src/main/ipc/register.test.ts`
+
+- [ ] **Step 1: Add the failing handler tests**
+
+In `src/main/ipc/register.test.ts`, add inside `describe('registerIpc', …)`:
+
+```ts
+  it('accounts:export returns a string that imports back to the account incl. secret', async () => {
+    const { handlers, deps } = buildHarness();
+    const created = (await handlers.get(CH.accountsCreate)!({
+      label: 'AWS', provider: 'amazon-s3', region: 'eu-central-1', accessKeyId: 'AK', secretAccessKey: 'SECRET',
+    })) as { ok: true; data: { id: string } };
+    const res = (await handlers.get(CH.accountsExport)!({ accountIds: [created.data.id] })) as { ok: boolean; data: string };
+    expect(res.ok).toBe(true);
+    // round-trip the produced blob with the pure importer
+    const { importAccounts } = await import('../accounts/accountTransfer');
+    const accounts = importAccounts(res.data);
+    expect(accounts).toEqual([
+      { label: 'AWS', provider: 'amazon-s3', region: 'eu-central-1', accessKeyId: 'AK', secretAccessKey: 'SECRET', endpoint: undefined, forcePathStyle: false },
+    ]);
+    void deps;
+  });
+
+  it('accounts:import creates the accounts and their secrets', async () => {
+    const { exportAccounts } = await import('../accounts/accountTransfer');
+    const blob = exportAccounts([
+      { label: 'Imported', provider: 'amazon-s3', region: 'us-east-1', accessKeyId: 'IK', secretAccessKey: 'IS' },
+    ]);
+    const { handlers, deps } = buildHarness();
+    const res = (await handlers.get(CH.accountsImport)!({ blob })) as { ok: boolean; data: { id: string }[] };
+    expect(res.ok).toBe(true);
+    expect(res.data).toHaveLength(1);
+    const list = deps.accounts.list();
+    expect(list.map((a) => a.label)).toContain('Imported');
+    expect(deps.secrets.get(res.data[0].id)).toBe('IS');
+  });
+
+  it('accounts:import rejects an unknown provider without creating anything', async () => {
+    const { exportAccounts } = await import('../accounts/accountTransfer');
+    const blob = exportAccounts([
+      { label: 'Bad', provider: 'not-a-provider' as never, region: 'x', accessKeyId: 'K', secretAccessKey: 'S' },
+    ]);
+    const { handlers, deps } = buildHarness();
+    const res = (await handlers.get(CH.accountsImport)!({ blob })) as { ok: boolean };
+    expect(res.ok).toBe(false);
+    expect(deps.accounts.list()).toHaveLength(0);
+  });
+```
+
+- [ ] **Step 2: Run to verify failure**
+
+Run: `npx vitest run src/main/ipc/register.test.ts`
+Expected: FAIL — `CH.accountsExport`/`CH.accountsImport` undefined.
+
+- [ ] **Step 3: Add channels (`channels.ts`)**
+
+In `CH`, after `accountsTest: 'accounts:test',`:
+
+```ts
+  accountsExport: 'accounts:export',
+  accountsImport: 'accounts:import',
+```
+
+In `ApiMap`, after the `[CH.accountsTest]` line:
+
+```ts
+  [CH.accountsExport]: { args: [{ accountIds: string[]; password?: string }]; res: Result<string> };
+  [CH.accountsImport]: { args: [{ blob: string; password?: string }]; res: Result<Account[]> };
+```
+
+- [ ] **Step 4: Add handlers (`register.ts`)**
+
+Add imports near the top (after the `createBucket` import):
+
+```ts
+import { exportAccounts, importAccounts, TransferError } from '../accounts/accountTransfer';
+import type { ExportAccount } from '../accounts/accountTransfer';
+```
+
+After the `h(CH.accountsTest, …)` handler block, add:
+
+```ts
+  h(CH.accountsExport, (a: { accountIds: string[]; password?: string }) => {
+    const accounts: ExportAccount[] = [];
+    for (const id of a.accountIds) {
+      const acc = deps.accounts.get(id);
+      if (!acc) continue;
+      const secret = deps.secrets.get(id);
+      if (secret === undefined) {
+        return err('SecretUnavailable', `Cannot read the secret for account "${acc.label}".`);
+      }
+      accounts.push({
+        label: acc.label,
+        provider: acc.provider,
+        region: acc.region,
+        accessKeyId: acc.accessKeyId,
+        secretAccessKey: secret,
+        endpoint: acc.endpoint,
+        forcePathStyle: acc.forcePathStyle,
+      });
+    }
+    if (accounts.length === 0) return err('NothingToExport', 'No accounts to export.');
+    return ok(exportAccounts(accounts, a.password));
+  });
+
+  h(CH.accountsImport, (a: { blob: string; password?: string }) => {
+    let parsed: ExportAccount[];
+    try {
+      parsed = importAccounts(a.blob, a.password);
+    } catch (e) {
+      if (e instanceof TransferError) return err(e.code, e.message);
+      throw e;
+    }
+    // Validate everything before creating anything (all-or-nothing).
+    const resolved: { acc: ExportAccount; params: ConnParams }[] = [];
+    for (const acc of parsed) {
+      if (!isKnownProvider(acc.provider)) {
+        return err('InvalidProvider', `Unknown provider: ${acc.provider}`);
+      }
+      const params = resolveConnParams(acc);
+      if (!params.ok) return params;
+      resolved.push({ acc, params: params.data });
+    }
+    const created = deps.db.transaction(() => {
+      return resolved.map(({ acc, params }) => {
+        const a2 = deps.accounts.create({
+          label: acc.label,
+          provider: acc.provider,
+          endpoint: params.endpoint,
+          region: acc.region,
+          accessKeyId: acc.accessKeyId,
+          forcePathStyle: params.forcePathStyle,
+        });
+        deps.secrets.set(a2.id, acc.secretAccessKey);
+        return a2;
+      });
+    })();
+    return ok(created);
+  });
+```
+
+- [ ] **Step 5: Expose in preload (`preload.ts`)**
+
+After the `test` line in the `accounts` object (`test: (input) => invoke(CH.accountsTest, input),`), add inside the same `accounts: { … }` object:
+
+```ts
+    export: (a: ApiMap[typeof CH.accountsExport]['args'][0]) => invoke(CH.accountsExport, a),
+    import: (a: ApiMap[typeof CH.accountsImport]['args'][0]) => invoke(CH.accountsImport, a),
+```
+
+- [ ] **Step 6: Run to verify pass + types + lint**
+
+Run: `npx vitest run src/main/ipc/register.test.ts` (pass).
+Run: `npx tsc --noEmit` (clean), `npm run lint` (0 errors).
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add src/main/ipc/channels.ts src/main/ipc/register.ts src/preload.ts src/main/ipc/register.test.ts
+git commit -m "feat(ipc): add accounts export/import channels" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 4: Renderer hooks + i18n keys
+
+**Files:**
+- Create: `src/renderer/hooks/useAccountTransfer.ts`
+- Test: `src/renderer/hooks/useAccountTransfer.test.tsx`
+- Modify: `src/renderer/i18n/locales/{en,de,fr,pl,nl,ro}.json`
+
+- [ ] **Step 1: Add all `transfer.*` i18n keys to the six locales**
+
+Add a new top-level `transfer` object to each locale. Values:
+
+| Key | en | de |
+| --- | --- | --- |
+| exportTitle | Export accounts | Konten exportieren |
+| importTitle | Import accounts | Konten importieren |
+| password | Password (optional) | Passwort (optional) |
+| importPassword | Password | Passwort |
+| noPasswordWarning | Without a password the secret keys are not encrypted — keep this export private. | Ohne Passwort sind die Secret Keys nicht verschlüsselt — halte diesen Export geheim. |
+| generate | Generate export | Export erzeugen |
+| copy | Copy | Kopieren |
+| copied | Copied | Kopiert |
+| download | Download | Herunterladen |
+| resultAria | Export string | Export-String |
+| pastePlaceholder | Paste the export string here | Export-String hier einfügen |
+| pasteAria | Import data | Importdaten |
+| loadFile | Load file | Datei laden |
+| import | Import | Importieren |
+| passwordRequired | This export is password-protected. Enter the password. | Dieser Export ist passwortgeschützt. Bitte Passwort eingeben. |
+| incorrectPassword | Incorrect password. | Falsches Passwort. |
+| invalidData | This doesn't look like a valid account export. | Das sieht nicht nach einem gültigen Konten-Export aus. |
+| imported | Imported {{count}} accounts | {{count}} Konten importiert |
+| importAccounts | Import | Importieren |
+| exportAll | Export all | Alle exportieren |
+| exportAria | Export {{label}} | {{label}} exportieren |
+
+| Key | fr | pl |
+| --- | --- | --- |
+| exportTitle | Exporter les comptes | Eksportuj konta |
+| importTitle | Importer des comptes | Importuj konta |
+| password | Mot de passe (optionnel) | Hasło (opcjonalne) |
+| importPassword | Mot de passe | Hasło |
+| noPasswordWarning | Sans mot de passe, les clés secrètes ne sont pas chiffrées — gardez cet export privé. | Bez hasła klucze tajne nie są szyfrowane — zachowaj ten eksport prywatnie. |
+| generate | Générer l'export | Wygeneruj eksport |
+| copy | Copier | Kopiuj |
+| copied | Copié | Skopiowano |
+| download | Télécharger | Pobierz |
+| resultAria | Chaîne d'export | Ciąg eksportu |
+| pastePlaceholder | Collez la chaîne d'export ici | Wklej tutaj ciąg eksportu |
+| pasteAria | Données d'import | Dane importu |
+| loadFile | Charger un fichier | Wczytaj plik |
+| import | Importer | Importuj |
+| passwordRequired | Cet export est protégé par mot de passe. Saisissez le mot de passe. | Ten eksport jest chroniony hasłem. Wprowadź hasło. |
+| incorrectPassword | Mot de passe incorrect. | Nieprawidłowe hasło. |
+| invalidData | Cela ne ressemble pas à un export de comptes valide. | To nie wygląda na prawidłowy eksport kont. |
+| imported | {{count}} comptes importés | Zaimportowano {{count}} kont |
+| importAccounts | Importer | Importuj |
+| exportAll | Tout exporter | Eksportuj wszystkie |
+| exportAria | Exporter {{label}} | Eksportuj {{label}} |
+
+| Key | nl | ro |
+| --- | --- | --- |
+| exportTitle | Accounts exporteren | Exportă conturile |
+| importTitle | Accounts importeren | Importă conturi |
+| password | Wachtwoord (optioneel) | Parolă (opțional) |
+| importPassword | Wachtwoord | Parolă |
+| noPasswordWarning | Zonder wachtwoord zijn de secret keys niet versleuteld — houd deze export privé. | Fără parolă, cheile secrete nu sunt criptate — păstrează acest export privat. |
+| generate | Export genereren | Generează exportul |
+| copy | Kopiëren | Copiază |
+| copied | Gekopieerd | Copiat |
+| download | Downloaden | Descarcă |
+| resultAria | Exportreeks | Șir de export |
+| pastePlaceholder | Plak hier de exportreeks | Lipește aici șirul de export |
+| pasteAria | Importgegevens | Date de import |
+| loadFile | Bestand laden | Încarcă fișier |
+| import | Importeren | Importă |
+| passwordRequired | Deze export is met een wachtwoord beveiligd. Voer het wachtwoord in. | Acest export este protejat cu parolă. Introdu parola. |
+| incorrectPassword | Onjuist wachtwoord. | Parolă incorectă. |
+| invalidData | Dit lijkt geen geldige accountexport. | Acesta nu pare un export de conturi valid. |
+| imported | {{count}} accounts geïmporteerd | {{count}} conturi importate |
+| importAccounts | Importeren | Importă |
+| exportAll | Alles exporteren | Exportă tot |
+| exportAria | {{label}} exporteren | Exportă {{label}} |
+
+After editing, validate JSON: `node -e "['en','de','fr','pl','nl','ro'].forEach(l=>JSON.parse(require('fs').readFileSync('src/renderer/i18n/locales/'+l+'.json','utf8')))"` (exit 0).
+
+- [ ] **Step 2: Write the failing hook test**
+
+Create `src/renderer/hooks/useAccountTransfer.test.tsx`:
+
+```tsx
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { renderHook, waitFor } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { ReactNode } from 'react';
+import { useExportAccounts, useImportAccounts } from './useAccountTransfer';
+
+function wrapper() {
+  const client = new QueryClient({ defaultOptions: { mutations: { retry: false } } });
+  return ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={client}>{children}</QueryClientProvider>
+  );
+}
+
+beforeEach(() => {
+  (window as unknown as { s3: unknown }).s3 = {
+    accounts: {
+      export: vi.fn().mockResolvedValue({ ok: true, data: 'BLOB' }),
+      import: vi.fn().mockResolvedValue({ ok: true, data: [{ id: 'n1' }] }),
+    },
+  };
+});
+
+describe('useExportAccounts', () => {
+  it('returns the export string', async () => {
+    const { result } = renderHook(() => useExportAccounts(), { wrapper: wrapper() });
+    result.current.mutate({ accountIds: ['a'], password: 'pw' });
+    await waitFor(() => expect(result.current.data).toBe('BLOB'));
+    expect((window.s3 as unknown as { accounts: { export: ReturnType<typeof vi.fn> } }).accounts.export)
+      .toHaveBeenCalledWith({ accountIds: ['a'], password: 'pw' });
+  });
+});
+
+describe('useImportAccounts', () => {
+  it('returns the imported accounts', async () => {
+    const { result } = renderHook(() => useImportAccounts(), { wrapper: wrapper() });
+    result.current.mutate({ blob: 'BLOB' });
+    await waitFor(() => expect(result.current.data).toEqual([{ id: 'n1' }]));
+  });
+});
+```
+
+- [ ] **Step 3: Run to verify failure**
+
+Run: `npx vitest run src/renderer/hooks/useAccountTransfer.test.tsx`
+Expected: FAIL — cannot resolve `./useAccountTransfer`.
+
+- [ ] **Step 4: Implement the hooks**
+
+Create `src/renderer/hooks/useAccountTransfer.ts`:
+
+```ts
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { unwrap } from '../lib/result';
+import { accountsKey } from './useAccounts';
+
+export function useExportAccounts() {
+  return useMutation({
+    mutationFn: async (input: { accountIds: string[]; password?: string }) =>
+      unwrap(await window.s3.accounts.export(input)),
+  });
+}
+
+export function useImportAccounts() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: async (input: { blob: string; password?: string }) =>
+      unwrap(await window.s3.accounts.import(input)),
+    onSuccess: () => qc.invalidateQueries({ queryKey: accountsKey }),
+  });
+}
+```
+
+(`accountsKey` is exported from `src/renderer/hooks/useAccounts.ts`.)
+
+- [ ] **Step 5: Run to verify pass + types + lint**
+
+Run: `npx vitest run src/renderer/hooks/useAccountTransfer.test.tsx` (pass).
+Run: `npx tsc --noEmit` (clean), `npm run lint` (0 errors).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/renderer/hooks/useAccountTransfer.ts src/renderer/hooks/useAccountTransfer.test.tsx src/renderer/i18n/locales/*.json
+git commit -m "feat(accounts): add transfer hooks and i18n keys" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 5: `ExportAccountsDialog`
+
+**Files:**
+- Create: `src/renderer/components/accounts/ExportAccountsDialog.tsx`
+- Test: `src/renderer/components/accounts/ExportAccountsDialog.test.tsx`
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `src/renderer/components/accounts/ExportAccountsDialog.test.tsx`:
+
+```tsx
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { ReactNode } from 'react';
+import { ToastProvider } from '../ui/ToastProvider';
+import { ExportAccountsDialog } from './ExportAccountsDialog';
+
+function wrap(node: ReactNode) {
+  const client = new QueryClient({ defaultOptions: { mutations: { retry: false } } });
+  return render(
+    <QueryClientProvider client={client}>
+      <ToastProvider>{node}</ToastProvider>
+    </QueryClientProvider>,
+  );
+}
+
+beforeEach(() => {
+  Object.assign(navigator, { clipboard: { writeText: vi.fn().mockResolvedValue(undefined) } });
+  (window as unknown as { s3: unknown }).s3 = {
+    accounts: { export: vi.fn().mockResolvedValue({ ok: true, data: 'EXPORT-BLOB' }) },
+    saveTextFile: vi.fn().mockResolvedValue({ ok: true, data: { saved: true } }),
+  };
+});
+
+describe('ExportAccountsDialog', () => {
+  it('warns when no password is set and generates the export string', async () => {
+    wrap(<ExportAccountsDialog accountIds={['a']} onClose={() => {}} />);
+    expect(screen.getByText(/secret keys are not encrypted/i)).toBeInTheDocument();
+    await userEvent.click(screen.getByRole('button', { name: 'Generate export' }));
+    const out = await screen.findByLabelText('Export string');
+    expect(out).toHaveValue('EXPORT-BLOB');
+  });
+
+  it('downloads the generated string via saveTextFile', async () => {
+    wrap(<ExportAccountsDialog accountIds={['a']} onClose={() => {}} />);
+    await userEvent.click(screen.getByRole('button', { name: 'Generate export' }));
+    await screen.findByLabelText('Export string');
+    await userEvent.click(screen.getByRole('button', { name: 'Download' }));
+    await waitFor(() =>
+      expect(window.s3.saveTextFile).toHaveBeenCalledWith({ defaultName: 's3manager-accounts.txt', contents: 'EXPORT-BLOB' }),
+    );
+  });
+
+  it('hides the warning once a password is entered', async () => {
+    wrap(<ExportAccountsDialog accountIds={['a']} onClose={() => {}} />);
+    await userEvent.type(screen.getByLabelText('Password (optional)'), 'pw');
+    expect(screen.queryByText(/secret keys are not encrypted/i)).not.toBeInTheDocument();
+  });
+});
+```
+
+- [ ] **Step 2: Run to verify failure**
+
+Run: `npx vitest run src/renderer/components/accounts/ExportAccountsDialog.test.tsx`
+Expected: FAIL — cannot resolve `./ExportAccountsDialog`.
+
+- [ ] **Step 3: Implement the dialog**
+
+Create `src/renderer/components/accounts/ExportAccountsDialog.tsx`:
+
+```tsx
+import { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { FiX } from 'react-icons/fi';
+import { useExportAccounts } from '../../hooks/useAccountTransfer';
+import { useToast } from '../ui/ToastProvider';
+
+export function ExportAccountsDialog({ accountIds, onClose }: { accountIds: string[]; onClose: () => void }) {
+  const { t } = useTranslation();
+  const { show } = useToast();
+  const exportAccounts = useExportAccounts();
+  const [password, setPassword] = useState('');
+  const [result, setResult] = useState<string | null>(null);
+
+  const onGenerate = async () => {
+    try {
+      const blob = await exportAccounts.mutateAsync({ accountIds, password: password || undefined });
+      setResult(blob);
+    } catch (e) {
+      show((e as Error).message, 'error');
+    }
+  };
+
+  const onCopy = async () => {
+    if (result === null) return;
+    await navigator.clipboard.writeText(result);
+    show(t('transfer.copied'));
+  };
+
+  const onDownload = async () => {
+    if (result === null) return;
+    await window.s3.saveTextFile({ defaultName: 's3manager-accounts.txt', contents: result });
+  };
+
+  const field = 'mt-1 w-full rounded border border-slate-300 px-2 py-1 text-sm dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100';
+
+  return (
+    <div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">
+      <div className="w-[28rem] max-w-[90vw] rounded bg-white p-4 shadow-lg dark:bg-slate-900">
+        <div className="flex items-center justify-between pb-2">
+          <p className="text-sm font-medium text-slate-800 dark:text-slate-100">{t('transfer.exportTitle')}</p>
+          <button type="button" aria-label={t('common.close')} className="rounded px-2 hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onClose}>
+            <FiX className="h-4 w-4" aria-hidden />
+          </button>
+        </div>
+
+        <label className="block text-sm">
+          {t('transfer.password')}
+          <input type="password" className={field} value={password} onChange={(e) => setPassword(e.target.value)} />
+        </label>
+        {password.length === 0 && (
+          <p className="mt-2 text-xs text-amber-600 dark:text-amber-400">{t('transfer.noPasswordWarning')}</p>
+        )}
+
+        {result === null ? (
+          <div className="mt-4 flex justify-end">
+            <button
+              type="button"
+              disabled={exportAccounts.isPending}
+              className="rounded bg-slate-800 px-3 py-1 text-sm text-white hover:bg-slate-700 disabled:opacity-40 dark:bg-slate-200 dark:text-slate-900"
+              onClick={onGenerate}
+            >
+              {t('transfer.generate')}
+            </button>
+          </div>
+        ) : (
+          <>
+            <textarea
+              aria-label={t('transfer.resultAria')}
+              readOnly
+              value={result}
+              className="mt-3 h-28 w-full resize-none rounded border border-slate-300 p-2 font-mono text-xs dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100"
+            />
+            <div className="mt-3 flex justify-end gap-2">
+              <button type="button" className="rounded border border-slate-300 px-3 py-1 text-sm hover:bg-slate-50 dark:border-slate-700 dark:hover:bg-slate-800" onClick={onCopy}>
+                {t('transfer.copy')}
+              </button>
+              <button type="button" className="rounded border border-slate-300 px-3 py-1 text-sm hover:bg-slate-50 dark:border-slate-700 dark:hover:bg-slate-800" onClick={onDownload}>
+                {t('transfer.download')}
+              </button>
+            </div>
+          </>
+        )}
+      </div>
+    </div>
+  );
+}
+```
+
+- [ ] **Step 4: Run to verify pass + types + lint**
+
+Run: `npx vitest run src/renderer/components/accounts/ExportAccountsDialog.test.tsx` (pass).
+Run: `npx tsc --noEmit` (clean), `npm run lint` (0 errors).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/renderer/components/accounts/ExportAccountsDialog.tsx src/renderer/components/accounts/ExportAccountsDialog.test.tsx
+git commit -m "feat(accounts): add export dialog" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 6: `ImportAccountsDialog`
+
+**Files:**
+- Create: `src/renderer/components/accounts/ImportAccountsDialog.tsx`
+- Test: `src/renderer/components/accounts/ImportAccountsDialog.test.tsx`
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `src/renderer/components/accounts/ImportAccountsDialog.test.tsx`:
+
+```tsx
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { ReactNode } from 'react';
+import { ToastProvider } from '../ui/ToastProvider';
+import { ImportAccountsDialog } from './ImportAccountsDialog';
+
+function wrap(node: ReactNode) {
+  const client = new QueryClient({ defaultOptions: { mutations: { retry: false } } });
+  return render(
+    <QueryClientProvider client={client}>
+      <ToastProvider>{node}</ToastProvider>
+    </QueryClientProvider>,
+  );
+}
+
+beforeEach(() => {
+  (window as unknown as { s3: unknown }).s3 = {
+    accounts: { import: vi.fn().mockResolvedValue({ ok: true, data: [{ id: 'n1' }, { id: 'n2' }] }) },
+    openTextFile: vi.fn().mockResolvedValue({ ok: true, data: 'FILE-BLOB' }),
+  };
+});
+
+describe('ImportAccountsDialog', () => {
+  it('imports a pasted blob and reports the count', async () => {
+    const onImported = vi.fn();
+    const onClose = vi.fn();
+    wrap(<ImportAccountsDialog onClose={onClose} onImported={onImported} />);
+    await userEvent.type(screen.getByLabelText('Import data'), 'BLOB');
+    await userEvent.click(screen.getByRole('button', { name: 'Import' }));
+    await waitFor(() => expect(onImported).toHaveBeenCalled());
+    expect(window.s3.accounts.import).toHaveBeenCalledWith({ blob: 'BLOB', password: undefined });
+    expect(onClose).toHaveBeenCalled();
+  });
+
+  it('loads a file into the textarea', async () => {
+    wrap(<ImportAccountsDialog onClose={() => {}} onImported={() => {}} />);
+    await userEvent.click(screen.getByRole('button', { name: 'Load file' }));
+    await waitFor(() => expect(screen.getByLabelText('Import data')).toHaveValue('FILE-BLOB'));
+  });
+
+  it('shows an inline error and stays open on an incorrect password', async () => {
+    (window.s3 as unknown as { accounts: { import: ReturnType<typeof vi.fn> } }).accounts.import = vi
+      .fn()
+      .mockResolvedValue({ ok: false, error: { code: 'IncorrectPassword', message: 'Incorrect password.' } });
+    const onClose = vi.fn();
+    wrap(<ImportAccountsDialog onClose={onClose} onImported={() => {}} />);
+    await userEvent.type(screen.getByLabelText('Import data'), 'BLOB');
+    await userEvent.click(screen.getByRole('button', { name: 'Import' }));
+    expect(await screen.findByText('Incorrect password.')).toBeInTheDocument();
+    expect(onClose).not.toHaveBeenCalled();
+  });
+});
+```
+
+- [ ] **Step 2: Run to verify failure**
+
+Run: `npx vitest run src/renderer/components/accounts/ImportAccountsDialog.test.tsx`
+Expected: FAIL — cannot resolve `./ImportAccountsDialog`.
+
+- [ ] **Step 3: Implement the dialog**
+
+Create `src/renderer/components/accounts/ImportAccountsDialog.tsx`:
+
+```tsx
+import { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { FiX } from 'react-icons/fi';
+import { useImportAccounts } from '../../hooks/useAccountTransfer';
+import { useToast } from '../ui/ToastProvider';
+
+export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => void; onImported: () => void }) {
+  const { t } = useTranslation();
+  const { show } = useToast();
+  const importAccounts = useImportAccounts();
+  const [blob, setBlob] = useState('');
+  const [password, setPassword] = useState('');
+  const [error, setError] = useState<string | null>(null);
+
+  const onLoadFile = async () => {
+    const text = await window.s3.openTextFile();
+    if (text.ok && text.data !== null) setBlob(text.data);
+  };
+
+  const onImport = async () => {
+    setError(null);
+    try {
+      const created = await importAccounts.mutateAsync({ blob, password: password || undefined });
+      show(t('transfer.imported', { count: created.length }));
+      onImported();
+      onClose();
+    } catch (e) {
+      setError((e as Error).message);
+    }
+  };
+
+  const field = 'mt-1 w-full rounded border border-slate-300 px-2 py-1 text-sm dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100';
+
+  return (
+    <div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">
+      <div className="w-[28rem] max-w-[90vw] rounded bg-white p-4 shadow-lg dark:bg-slate-900">
+        <div className="flex items-center justify-between pb-2">
+          <p className="text-sm font-medium text-slate-800 dark:text-slate-100">{t('transfer.importTitle')}</p>
+          <button type="button" aria-label={t('common.close')} className="rounded px-2 hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onClose}>
+            <FiX className="h-4 w-4" aria-hidden />
+          </button>
+        </div>
+
+        <textarea
+          aria-label={t('transfer.pasteAria')}
+          placeholder={t('transfer.pastePlaceholder')}
+          value={blob}
+          onChange={(e) => setBlob(e.target.value)}
+          className="h-28 w-full resize-none rounded border border-slate-300 p-2 font-mono text-xs dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100"
+        />
+        <div className="mt-2">
+          <button type="button" className="rounded border border-slate-300 px-3 py-1 text-sm hover:bg-slate-50 dark:border-slate-700 dark:hover:bg-slate-800" onClick={onLoadFile}>
+            {t('transfer.loadFile')}
+          </button>
+        </div>
+
+        <label className="mt-3 block text-sm">
+          {t('transfer.importPassword')}
+          <input type="password" className={field} value={password} onChange={(e) => setPassword(e.target.value)} />
+        </label>
+
+        {error !== null && <p className="mt-2 text-xs text-red-600 dark:text-red-400">{error}</p>}
+
+        <div className="mt-4 flex justify-end gap-2">
+          <button type="button" className="rounded px-3 py-1 text-sm hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onClose}>
+            {t('common.cancel')}
+          </button>
+          <button
+            type="button"
+            disabled={blob.trim().length === 0 || importAccounts.isPending}
+            className="rounded bg-slate-800 px-3 py-1 text-sm text-white hover:bg-slate-700 disabled:opacity-40 dark:bg-slate-200 dark:text-slate-900"
+            onClick={onImport}
+          >
+            {t('transfer.import')}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
+```
+
+- [ ] **Step 4: Run to verify pass + types + lint**
+
+Run: `npx vitest run src/renderer/components/accounts/ImportAccountsDialog.test.tsx` (pass).
+Run: `npx tsc --noEmit` (clean), `npm run lint` (0 errors).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/renderer/components/accounts/ImportAccountsDialog.tsx src/renderer/components/accounts/ImportAccountsDialog.test.tsx
+git commit -m "feat(accounts): add import dialog" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 7: `ConnectionsScreen` entry points
+
+**Files:**
+- Modify: `src/renderer/components/connections/ConnectionsScreen.tsx`
+- Modify: `src/renderer/components/connections/ConnectionsScreen.test.tsx`
+
+- [ ] **Step 1: Add the failing tests**
+
+Append to the `describe('ConnectionsScreen', …)` block in `src/renderer/components/connections/ConnectionsScreen.test.tsx`. The shared `beforeEach` mock has only `accounts.list`/`accounts.remove`; these tests just open dialogs (no export/import call needed to open):
+
+```tsx
+  it('opens the export dialog from a row export button', async () => {
+    wrap(<ConnectionsScreen />);
+    await userEvent.click(await screen.findByRole('button', { name: 'Export AWS prod' }));
+    expect(screen.getByText('Export accounts', { selector: 'p' })).toBeInTheDocument();
+  });
+
+  it('opens the import dialog from the header', async () => {
+    wrap(<ConnectionsScreen />);
+    await userEvent.click(await screen.findByRole('button', { name: 'Import' }));
+    expect(screen.getByText('Import accounts', { selector: 'p' })).toBeInTheDocument();
+  });
+
+  it('opens the export-all dialog from the header', async () => {
+    wrap(<ConnectionsScreen />);
+    await userEvent.click(await screen.findByRole('button', { name: 'Export all' }));
+    expect(screen.getByText('Export accounts', { selector: 'p' })).toBeInTheDocument();
+  });
+
+  it('disables export-all when there are no accounts', async () => {
+    (window.s3 as unknown as { accounts: { list: ReturnType<typeof vi.fn> } }).accounts.list = vi
+      .fn()
+      .mockResolvedValue({ ok: true, data: [] });
+    wrap(<ConnectionsScreen />);
+    await waitFor(() => expect(screen.getByRole('button', { name: 'Export all' })).toBeDisabled());
+  });
+```
+
+- [ ] **Step 2: Run to verify failure**
+
+Run: `npx vitest run src/renderer/components/connections/ConnectionsScreen.test.tsx`
+Expected: FAIL — no Import / Export all / row Export buttons yet.
+
+- [ ] **Step 3: Implement the entry points**
+
+In `src/renderer/components/connections/ConnectionsScreen.tsx`:
+
+Change the icon import line to add `FiDownload`/`FiUpload`:
+
+```tsx
+import { FiTrash2, FiEdit2, FiUpload } from 'react-icons/fi';
+```
+
+Add the dialog imports:
+
+```tsx
+import { ExportAccountsDialog } from '../accounts/ExportAccountsDialog';
+import { ImportAccountsDialog } from '../accounts/ImportAccountsDialog';
+```
+
+Add dialog state inside the component (after `const [editing, setEditing] = useState<Editing>(null);`):
+
+```tsx
+  // null = closed; string[] = export those ids; 'import' = import dialog
+  const [transfer, setTransfer] = useState<null | { kind: 'export'; ids: string[] } | { kind: 'import' }>(null);
+```
+
+Replace the header block (the `<div className="flex items-center justify-between pb-3">…</div>`) with one that adds Import + Export all next to Add account:
+
+```tsx
+      <div className="flex items-center justify-between pb-3">
+        <h2 className="text-lg font-semibold">{t('connections.title')}</h2>
+        {editing === null && (
+          <div className="flex items-center gap-2">
+            <button
+              type="button"
+              className="rounded border border-slate-300 dark:border-slate-700 px-3 py-1 text-sm hover:bg-slate-50 dark:hover:bg-slate-800"
+              onClick={() => setTransfer({ kind: 'import' })}
+            >
+              {t('transfer.importAccounts')}
+            </button>
+            <button
+              type="button"
+              disabled={!accounts.data || accounts.data.length === 0}
+              className="rounded border border-slate-300 dark:border-slate-700 px-3 py-1 text-sm hover:bg-slate-50 dark:hover:bg-slate-800 disabled:opacity-40"
+              onClick={() => setTransfer({ kind: 'export', ids: (accounts.data ?? []).map((a) => a.id) })}
+            >
+              {t('transfer.exportAll')}
+            </button>
+            <button
+              type="button"
+              className="rounded border border-slate-300 dark:border-slate-700 px-3 py-1 text-sm hover:bg-slate-50 dark:hover:bg-slate-800"
+              onClick={() => setEditing('new')}
+            >
+              {t('connections.addAccount')}
+            </button>
+          </div>
+        )}
+      </div>
+```
+
+Add a row export button — inside the per-row `<div className="flex items-center gap-1">`, before the edit button:
+
+```tsx
+                  <button
+                    type="button"
+                    aria-label={t('transfer.exportAria', { label: acc.label })}
+                    className="rounded px-1 text-slate-400 dark:text-slate-500 hover:bg-slate-100 dark:hover:bg-slate-800 hover:text-slate-700 dark:hover:text-slate-200"
+                    onClick={() => setTransfer({ kind: 'export', ids: [acc.id] })}
+                  >
+                    <FiUpload className="h-4 w-4" aria-hidden />
+                  </button>
+```
+
+Render the dialogs — add just before the final closing `</div>` of the component's outer wrapper:
+
+```tsx
+      {transfer?.kind === 'export' && (
+        <ExportAccountsDialog accountIds={transfer.ids} onClose={() => setTransfer(null)} />
+      )}
+      {transfer?.kind === 'import' && (
+        <ImportAccountsDialog onClose={() => setTransfer(null)} onImported={() => undefined} />
+      )}
+```
+
+(The import dialog already invalidates the accounts query via `useImportAccounts`; `onImported` can be a no-op here.)
+
+- [ ] **Step 4: Run to verify pass**
+
+Run: `npx vitest run src/renderer/components/connections/ConnectionsScreen.test.tsx`
+Expected: PASS (existing + 4 new).
+
+- [ ] **Step 5: Full suite + types + lint**
+
+Run: `npm test` (all green), `npx tsc --noEmit` (clean), `npm run lint` (0 errors).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/renderer/components/connections/ConnectionsScreen.tsx src/renderer/components/connections/ConnectionsScreen.test.tsx
+git commit -m "feat(accounts): export/import entry points in the Accounts screen" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+## Self-review notes
+
+- **Spec coverage:** transfer module + crypto (Task 1); file helpers (Task 2); export/import IPC incl. all-or-nothing + new ids (Task 3); hooks + i18n (Task 4); export dialog w/ password warning + copy + download (Task 5); import dialog w/ paste + load-file + inline password errors (Task 6); per-account + export-all + import entry points (Task 7). All spec sections covered.
+- **Type consistency:** `ExportAccount` defined in Task 1, imported in Task 3; `accountsExport`/`accountsImport` arg shapes match across channels (Task 3), preload (Task 3), hooks (Task 4), and dialogs (Tasks 5/6); `TransferError.code` ∈ {PasswordRequired, IncorrectPassword, InvalidData} mapped to `err(code, …)` in Task 3 and surfaced inline in Task 6; `ConnParams`/`resolveConnParams` reused from existing register.ts code in Task 3.
+- **Existing-test impact:** Task 2 relies on `buildHarness(overrides)` (present from the update-check branch; fallback noted). Task 7's new tests open dialogs only; the dialogs call `accounts.export`/`import` only on user action, which these tests don't trigger except where mocked.
+- **Security:** secrets never logged; password optional with a visible plaintext warning; AES-256-GCM + scrypt; import all-or-nothing; new ids only.
diff --git a/docs/superpowers/plans/2026-06-16-duplicate-and-modal.md b/docs/superpowers/plans/2026-06-16-duplicate-and-modal.md
new file mode 100644
index 0000000..b16cab4
--- /dev/null
+++ b/docs/superpowers/plans/2026-06-16-duplicate-and-modal.md
@@ -0,0 +1,534 @@
+# Duplicate Import & Dismissible Modals Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Warn + offer skip/copy/replace when an imported account name already exists, and make all 10 modals dismissible via Esc and backdrop click through a shared `Modal` wrapper.
+
+**Architecture:** `accountsImport` gains an `onDuplicate` mode applied per name-collision inside its transaction. A new `ui/Modal` owns the overlay + Esc/backdrop dismissal; the 10 dialogs adopt it. The import dialog detects collisions from its preview list and surfaces the chooser.
+
+**Tech Stack:** Electron Forge, TypeScript, TanStack Query, react-i18next (6 locales), Vitest + Testing Library.
+
+**Spec:** `docs/superpowers/specs/2026-06-16-duplicate-and-modal-design.md`
+
+**Conventions:** `Result<T>` via `ok`/`err`; renderer `unwrap()`; `Account = { id, label, provider, region, accessKeyId, endpoint?, forcePathStyle, createdAt }`; `deps.accounts.update(id, NewAccount)` updates in place. Tests load real i18n (English). `npx vitest run <path>`, `npx tsc --noEmit`, `npm run lint`. Conventional Commits, footer `Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>`. No pushing. Branch: `feat/account-import-export`.
+
+---
+
+### Task 1: `accountsImport` duplicate mode
+
+**Files:**
+- Modify: `src/main/ipc/channels.ts`, `src/main/ipc/register.ts`, `src/main/ipc/register.test.ts`, `src/renderer/hooks/useAccountTransfer.ts`
+
+- [ ] **Step 1: Add the failing handler tests**
+
+In `src/main/ipc/register.test.ts`, add inside `describe('registerIpc', …)`:
+
+```ts
+  it('accounts:import skips a same-named account when onDuplicate=skip', async () => {
+    const { exportAccounts } = await import('../accounts/accountTransfer');
+    const { handlers, deps } = buildHarness();
+    await handlers.get(CH.accountsCreate)!({ label: 'AWS', provider: 'amazon-s3', region: 'eu-central-1', accessKeyId: 'OLD', secretAccessKey: 'OLDS' });
+    const blob = exportAccounts([
+      { label: 'AWS', provider: 'amazon-s3', region: 'us-east-1', accessKeyId: 'NEW', secretAccessKey: 'NEWS' },
+      { label: 'Fresh', provider: 'amazon-s3', region: 'us-east-1', accessKeyId: 'FK', secretAccessKey: 'FS' },
+    ]);
+    const res = (await handlers.get(CH.accountsImport)!({ blob, onDuplicate: 'skip' })) as { ok: boolean; data: { label: string }[] };
+    expect(res.ok).toBe(true);
+    expect(res.data.map((a) => a.label)).toEqual(['Fresh']);
+    expect(deps.accounts.list().filter((a) => a.label === 'AWS')).toHaveLength(1);
+    expect(deps.accounts.list().find((a) => a.label === 'AWS')!.accessKeyId).toBe('OLD');
+  });
+
+  it('accounts:import creates a copy when onDuplicate=copy (default)', async () => {
+    const { exportAccounts } = await import('../accounts/accountTransfer');
+    const { handlers, deps } = buildHarness();
+    await handlers.get(CH.accountsCreate)!({ label: 'AWS', provider: 'amazon-s3', region: 'eu-central-1', accessKeyId: 'OLD', secretAccessKey: 'OLDS' });
+    const blob = exportAccounts([{ label: 'AWS', provider: 'amazon-s3', region: 'us-east-1', accessKeyId: 'NEW', secretAccessKey: 'NEWS' }]);
+    const res = (await handlers.get(CH.accountsImport)!({ blob })) as { ok: boolean };
+    expect(res.ok).toBe(true);
+    expect(deps.accounts.list().filter((a) => a.label === 'AWS')).toHaveLength(2);
+  });
+
+  it('accounts:import overwrites the existing account when onDuplicate=replace', async () => {
+    const { exportAccounts } = await import('../accounts/accountTransfer');
+    const { handlers, deps } = buildHarness();
+    const created = (await handlers.get(CH.accountsCreate)!({ label: 'AWS', provider: 'amazon-s3', region: 'eu-central-1', accessKeyId: 'OLD', secretAccessKey: 'OLDS' })) as { data: { id: string } };
+    const blob = exportAccounts([{ label: 'AWS', provider: 'amazon-s3', region: 'us-east-1', accessKeyId: 'NEW', secretAccessKey: 'NEWS' }]);
+    const res = (await handlers.get(CH.accountsImport)!({ blob, onDuplicate: 'replace' })) as { ok: boolean; data: { id: string }[] };
+    expect(res.ok).toBe(true);
+    const list = deps.accounts.list().filter((a) => a.label === 'AWS');
+    expect(list).toHaveLength(1);
+    expect(list[0].id).toBe(created.data.id);
+    expect(list[0].accessKeyId).toBe('NEW');
+    expect(deps.secrets.get(created.data.id)).toBe('NEWS');
+  });
+```
+
+- [ ] **Step 2: Run to verify failure**
+
+Run: `npx vitest run src/main/ipc/register.test.ts`
+Expected: FAIL — `onDuplicate` ignored (current handler always creates).
+
+- [ ] **Step 3: Widen the channel arg (`channels.ts`)**
+
+Replace the `[CH.accountsImport]` line with:
+
+```ts
+  [CH.accountsImport]: { args: [{ blob: string; password?: string; onDuplicate?: 'skip' | 'copy' | 'replace' }]; res: Result<Account[]> };
+```
+
+- [ ] **Step 4: Apply the mode in the handler (`register.ts`)**
+
+Replace the whole `h(CH.accountsImport, …)` handler with:
+
+```ts
+  h(CH.accountsImport, (a: { blob: string; password?: string; onDuplicate?: 'skip' | 'copy' | 'replace' }) => {
+    let parsed: ExportAccount[];
+    try {
+      parsed = importAccounts(a.blob, a.password);
+    } catch (e) {
+      if (e instanceof TransferError) return err(e.code, e.message);
+      throw e;
+    }
+    const resolved: { acc: ExportAccount; params: ConnParams }[] = [];
+    for (const acc of parsed) {
+      if (!isKnownProvider(acc.provider)) {
+        return err('InvalidProvider', `Unknown provider: ${acc.provider}`);
+      }
+      const params = resolveConnParams(acc);
+      if (!params.ok) return params;
+      resolved.push({ acc, params: params.data });
+    }
+    const mode = a.onDuplicate ?? 'copy';
+    const existing = deps.accounts.list();
+    const result = deps.db.transaction(() => {
+      const out = [];
+      for (const { acc, params } of resolved) {
+        const dup = existing.find((e) => e.label === acc.label);
+        const fields = {
+          label: acc.label,
+          provider: acc.provider,
+          endpoint: params.endpoint,
+          region: acc.region,
+          accessKeyId: acc.accessKeyId,
+          forcePathStyle: params.forcePathStyle,
+        };
+        if (dup && mode === 'skip') {
+          continue;
+        }
+        if (dup && mode === 'replace') {
+          const updated = deps.accounts.update(dup.id, fields);
+          deps.secrets.set(dup.id, acc.secretAccessKey);
+          out.push(updated);
+        } else {
+          const a2 = deps.accounts.create(fields);
+          deps.secrets.set(a2.id, acc.secretAccessKey);
+          out.push(a2);
+        }
+      }
+      return out;
+    })();
+    return ok(result);
+  });
+```
+
+- [ ] **Step 5: Widen the hook input type (`useAccountTransfer.ts`)**
+
+In `useImportAccounts`, change the mutationFn input type:
+
+```ts
+    mutationFn: async (input: { blob: string; password?: string; onDuplicate?: 'skip' | 'copy' | 'replace' }) =>
+      unwrap(await window.s3.accounts.import(input)),
+```
+
+- [ ] **Step 6: Run to verify pass + types + lint**
+
+Run: `npx vitest run src/main/ipc/register.test.ts` (pass). `npx tsc --noEmit` (clean). `npm run lint` (0 errors).
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add src/main/ipc/channels.ts src/main/ipc/register.ts src/main/ipc/register.test.ts src/renderer/hooks/useAccountTransfer.ts
+git commit -m "feat(accounts): import duplicate mode (skip/copy/replace)" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 2: shared `Modal` wrapper
+
+**Files:**
+- Create: `src/renderer/components/ui/Modal.tsx`
+- Test: `src/renderer/components/ui/Modal.test.tsx`
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `src/renderer/components/ui/Modal.test.tsx`:
+
+```tsx
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { Modal } from './Modal';
+
+describe('Modal', () => {
+  it('renders a dialog with the panel content', () => {
+    render(<Modal onDismiss={() => {}} className="w-96">hi</Modal>);
+    expect(screen.getByRole('dialog')).toBeInTheDocument();
+    expect(screen.getByText('hi')).toBeInTheDocument();
+  });
+
+  it('dismisses on Escape', async () => {
+    const onDismiss = vi.fn();
+    render(<Modal onDismiss={onDismiss}>hi</Modal>);
+    await userEvent.keyboard('{Escape}');
+    expect(onDismiss).toHaveBeenCalledTimes(1);
+  });
+
+  it('dismisses on a backdrop click', async () => {
+    const onDismiss = vi.fn();
+    render(<Modal onDismiss={onDismiss}>hi</Modal>);
+    await userEvent.click(screen.getByRole('dialog'));
+    expect(onDismiss).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not dismiss when clicking inside the panel', async () => {
+    const onDismiss = vi.fn();
+    render(<Modal onDismiss={onDismiss}><button type="button">inside</button></Modal>);
+    await userEvent.click(screen.getByText('inside'));
+    expect(onDismiss).not.toHaveBeenCalled();
+  });
+});
+```
+
+- [ ] **Step 2: Run to verify failure**
+
+Run: `npx vitest run src/renderer/components/ui/Modal.test.tsx`
+Expected: FAIL — cannot resolve `./Modal`.
+
+- [ ] **Step 3: Implement**
+
+Create `src/renderer/components/ui/Modal.tsx`:
+
+```tsx
+import { useEffect, type ReactNode } from 'react';
+
+export function Modal({
+  onDismiss,
+  className,
+  children,
+}: {
+  onDismiss: () => void;
+  className?: string;
+  children: ReactNode;
+}) {
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === 'Escape') onDismiss();
+    };
+    document.addEventListener('keydown', onKey);
+    return () => document.removeEventListener('keydown', onKey);
+  }, [onDismiss]);
+
+  return (
+    <div
+      className="fixed inset-0 z-10 flex items-center justify-center bg-black/30"
+      role="dialog"
+      aria-modal="true"
+      onMouseDown={(e) => {
+        if (e.target === e.currentTarget) onDismiss();
+      }}
+    >
+      <div className={className ?? 'rounded bg-white p-4 shadow-lg dark:bg-slate-900'}>{children}</div>
+    </div>
+  );
+}
+```
+
+Note: backdrop dismissal uses `onMouseDown` with `e.target === e.currentTarget` so a click that starts inside the panel (e.g. a drag-select) never dismisses. The panel needs no `stopPropagation`. (The test's `userEvent.click` on the overlay triggers the mousedown on `currentTarget`.)
+
+- [ ] **Step 4: Run to verify pass + lint**
+
+Run: `npx vitest run src/renderer/components/ui/Modal.test.tsx` (pass, 4 tests). `npx tsc --noEmit` (clean). `npm run lint` (0 errors).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/renderer/components/ui/Modal.tsx src/renderer/components/ui/Modal.test.tsx
+git commit -m "feat(ui): add dismissible Modal wrapper (Esc + backdrop)" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 3: adopt `Modal` in 5 dialogs (accounts/buckets/confirm)
+
+**Files:**
+- Modify: `src/renderer/components/accounts/ExportAccountsDialog.tsx`, `src/renderer/components/accounts/ImportAccountsDialog.tsx`, `src/renderer/components/accounts/QuickAddAccountDialog.tsx`, `src/renderer/components/buckets/CreateBucketDialog.tsx`, `src/renderer/components/ui/ConfirmDialog.tsx`
+
+The transformation for each dialog: add `import { Modal } from '<relative>/ui/Modal';` and replace the outer overlay + panel:
+
+```tsx
+    <div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">
+      <div className="<PANEL CLASSES>">
+        … content …
+      </div>
+    </div>
+```
+
+with:
+
+```tsx
+    <Modal onDismiss={<HANDLER>} className="<PANEL CLASSES>">
+      … content …
+    </Modal>
+```
+
+Per-dialog values (read each file to copy its exact `<PANEL CLASSES>`):
+
+| Dialog | import path | HANDLER | panel classes |
+| --- | --- | --- | --- |
+| `ExportAccountsDialog` | `../ui/Modal` | `onClose` | `w-[28rem] max-w-[90vw] rounded bg-white p-4 shadow-lg dark:bg-slate-900` |
+| `ImportAccountsDialog` | `../ui/Modal` | `onClose` | `w-[28rem] max-w-[90vw] rounded bg-white p-4 shadow-lg dark:bg-slate-900` |
+| `QuickAddAccountDialog` | `../ui/Modal` | `onClose` | (read it — it includes `max-h-[90vh] … overflow-auto … w-96 …`) |
+| `CreateBucketDialog` | `../ui/Modal` | `onClose` | `w-96 rounded bg-white p-4 shadow-lg dark:bg-slate-900` |
+| `ConfirmDialog` | `./Modal` | `onCancel` | `w-80 rounded bg-white p-4 shadow-lg dark:bg-slate-900` |
+
+- [ ] **Step 1: Refactor all 5 dialogs**
+
+For each dialog: read it, apply the transformation above using its HANDLER and its exact panel classes, keep all inner content unchanged. Remove only the two wrapper `<div>`s (overlay + panel) — `Modal` provides `role="dialog"`/`aria-modal` and the panel `<div className=…>`.
+
+- [ ] **Step 2: Run the affected dialog tests**
+
+Run: `npx vitest run src/renderer/components/accounts/ src/renderer/components/buckets/CreateBucketDialog.test.tsx src/renderer/components/ui/ConfirmDialog.test.tsx`
+Expected: PASS — the existing tests query content/role/buttons, all preserved.
+
+- [ ] **Step 3: Add an Esc test to ConfirmDialog**
+
+Append to `src/renderer/components/ui/ConfirmDialog.test.tsx` (inside its describe; it already imports render/screen/userEvent/vi):
+
+```tsx
+  it('cancels on Escape', async () => {
+    const onCancel = vi.fn();
+    render(<ConfirmDialog message="Sure?" confirmLabel="Yes" onConfirm={() => {}} onCancel={onCancel} />);
+    await userEvent.keyboard('{Escape}');
+    expect(onCancel).toHaveBeenCalledTimes(1);
+  });
+```
+
+(If `ConfirmDialog.test.tsx` lacks `userEvent`, add `import userEvent from '@testing-library/user-event';`.)
+
+- [ ] **Step 4: Types + lint + commit**
+
+Run: `npx tsc --noEmit` (clean), `npm run lint` (0 errors), then:
+
+```bash
+git add src/renderer/components/accounts/ src/renderer/components/buckets/CreateBucketDialog.tsx src/renderer/components/ui/ConfirmDialog.tsx src/renderer/components/ui/ConfirmDialog.test.tsx
+git commit -m "refactor(ui): adopt Modal in account/bucket/confirm dialogs" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 4: adopt `Modal` in 5 dialogs (files/transfer)
+
+**Files:**
+- Modify: `src/renderer/components/files/MetadataDialog.tsx`, `src/renderer/components/files/PermissionsDialog.tsx`, `src/renderer/components/files/UploadLinkDialog.tsx`, `src/renderer/components/transfer/MoveDialog.tsx`, `src/renderer/components/transfer/NameDialog.tsx`
+
+Same transformation as Task 3. Per-dialog values:
+
+| Dialog | import path | HANDLER | panel classes |
+| --- | --- | --- | --- |
+| `MetadataDialog` | `../ui/Modal` | `onClose` | (read it — copy the panel `<div>`'s className verbatim) |
+| `PermissionsDialog` | `../ui/Modal` | `onClose` | (read it — copy verbatim) |
+| `UploadLinkDialog` | `../ui/Modal` | `onClose` | `w-[28rem] rounded bg-white p-4 shadow-lg dark:bg-slate-900` |
+| `MoveDialog` | `../ui/Modal` | `onClose` | `w-96 rounded bg-white p-4 shadow-lg dark:bg-slate-900` |
+| `NameDialog` | `../ui/Modal` | `onCancel` | `w-80 rounded bg-white p-4 shadow-lg dark:bg-slate-900` |
+
+- [ ] **Step 1: Refactor all 5 dialogs**
+
+For each: read it, replace the outer overlay + panel `<div>`s with `<Modal onDismiss={HANDLER} className="<exact panel classes>">…</Modal>`, add the Modal import, keep inner content unchanged. NameDialog's panel `<div>` spans multiple lines (its className is on its own line) — move that className to the `Modal`'s `className`.
+
+- [ ] **Step 2: Run the affected dialog tests**
+
+Run: `npx vitest run src/renderer/components/files/ src/renderer/components/transfer/`
+Expected: PASS (content/role/buttons preserved).
+
+- [ ] **Step 3: Types + lint + commit**
+
+Run: `npx tsc --noEmit` (clean), `npm run lint` (0 errors), then:
+
+```bash
+git add src/renderer/components/files/MetadataDialog.tsx src/renderer/components/files/PermissionsDialog.tsx src/renderer/components/files/UploadLinkDialog.tsx src/renderer/components/transfer/MoveDialog.tsx src/renderer/components/transfer/NameDialog.tsx
+git commit -m "refactor(ui): adopt Modal in files/transfer dialogs" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 5: duplicate warning + chooser in the import dialog
+
+**Files:**
+- Modify: `src/renderer/i18n/locales/{en,de,fr,pl,nl,ro}.json`
+- Modify: `src/renderer/components/accounts/ImportAccountsDialog.tsx`
+- Modify: `src/renderer/components/accounts/ImportAccountsDialog.test.tsx`
+
+- [ ] **Step 1: Add i18n keys (6 locales, in the `transfer` object)**
+
+| Key | en | de |
+| --- | --- | --- |
+| duplicateWarning | {{count}} names already exist | {{count}} Namen existieren bereits |
+| duplicateMode | Existing names | Vorhandene Namen |
+| duplicateSkip | Skip | Überspringen |
+| duplicateCopy | Import as copies | Als Kopie importieren |
+| duplicateReplace | Replace existing | Vorhandene ersetzen |
+| nameExists | name exists | Name existiert |
+
+| Key | fr | pl |
+| --- | --- | --- |
+| duplicateWarning | {{count}} noms existent déjà | {{count}} nazw już istnieje |
+| duplicateMode | Noms existants | Istniejące nazwy |
+| duplicateSkip | Ignorer | Pomiń |
+| duplicateCopy | Importer comme copies | Importuj jako kopie |
+| duplicateReplace | Remplacer l'existant | Zastąp istniejące |
+| nameExists | nom existant | nazwa istnieje |
+
+| Key | nl | ro |
+| --- | --- | --- |
+| duplicateWarning | {{count}} namen bestaan al | {{count}} nume există deja |
+| duplicateMode | Bestaande namen | Nume existente |
+| duplicateSkip | Overslaan | Omite |
+| duplicateCopy | Als kopie importeren | Importă drept copii |
+| duplicateReplace | Bestaande vervangen | Înlocuiește existentele |
+| nameExists | naam bestaat | numele există |
+
+Validate: `node -e "['en','de','fr','pl','nl','ro'].forEach(l=>JSON.parse(require('fs').readFileSync('src/renderer/i18n/locales/'+l+'.json','utf8')))"`.
+
+- [ ] **Step 2: Add the failing tests**
+
+Append to the `describe('ImportAccountsDialog', …)` block in `ImportAccountsDialog.test.tsx`. Extend the `setS3` helper to allow an `accounts.list` mock (existing accounts) — add `list` to the default accounts mock:
+
+In the `setS3` function, add `list: vi.fn().mockResolvedValue({ ok: true, data: [] }),` to the default `accounts` object (so `useAccounts` resolves). Then add:
+
+```tsx
+  it('warns about a name collision and imports with the chosen mode', async () => {
+    setS3({
+      list: vi.fn().mockResolvedValue({ ok: true, data: [{ id: 'x', label: 'AWS prod', provider: 'amazon-s3', region: 'r', accessKeyId: 'K', createdAt: 1 }] }),
+    });
+    const onImported = vi.fn();
+    wrap(<ImportAccountsDialog onClose={() => {}} onImported={onImported} />);
+    await userEvent.type(screen.getByLabelText('Import data'), 'BLOB');
+    expect(await screen.findByText('1 names already exist')).toBeInTheDocument();
+    await userEvent.selectOptions(screen.getByLabelText('Existing names'), 'replace');
+    await userEvent.click(screen.getByRole('button', { name: 'Import' }));
+    await waitFor(() => expect(window.s3.accounts.import).toHaveBeenCalledWith({ blob: 'BLOB', password: undefined, onDuplicate: 'replace' }));
+    expect(onImported).toHaveBeenCalled();
+  });
+
+  it('imports with copy mode when there is no collision', async () => {
+    wrap(<ImportAccountsDialog onClose={() => {}} onImported={() => {}} />);
+    await userEvent.type(screen.getByLabelText('Import data'), 'BLOB');
+    await screen.findByText('AWS prod (Amazon S3)');
+    expect(screen.queryByLabelText('Existing names')).not.toBeInTheDocument();
+    await userEvent.click(screen.getByRole('button', { name: 'Import' }));
+    await waitFor(() => expect(window.s3.accounts.import).toHaveBeenCalledWith({ blob: 'BLOB', password: undefined, onDuplicate: 'copy' }));
+  });
+```
+
+`waitFor` is already imported in that file (it uses it elsewhere); if not, add it to the `@testing-library/react` import. The default `importPreview` mock returns `accounts: [{ label: 'AWS prod', provider: 'amazon-s3' }]`, so the first test (existing label 'AWS prod') collides.
+
+- [ ] **Step 3: Run to verify failure**
+
+Run: `npx vitest run src/renderer/components/accounts/ImportAccountsDialog.test.tsx`
+Expected: FAIL — no collision warning/chooser; import omits `onDuplicate`.
+
+- [ ] **Step 4: Implement the collision UI**
+
+In `src/renderer/components/accounts/ImportAccountsDialog.tsx`:
+
+Add imports:
+
+```tsx
+import { useAccounts } from '../../hooks/useAccounts';
+```
+
+Inside the component, after the existing state declarations, add:
+
+```tsx
+  const existingAccounts = useAccounts();
+  const [duplicateMode, setDuplicateMode] = useState<'skip' | 'copy' | 'replace'>('skip');
+```
+
+After `const accounts = preview?.accounts ?? null;`, add:
+
+```tsx
+  const existingLabels = new Set((existingAccounts.data ?? []).map((a) => a.label));
+  const collisions = accounts?.filter((a) => existingLabels.has(a.label)) ?? [];
+```
+
+In `onImport`, change the mutate call to pass the mode:
+
+```tsx
+      const created = await importAccounts.mutateAsync({
+        blob,
+        password: password || undefined,
+        onDuplicate: collisions.length > 0 ? duplicateMode : 'copy',
+      });
+```
+
+In the preview list rendering, mark colliding rows — replace the `<li>` map with:
+
+```tsx
+                {accounts.map((a, i) => (
+                  <li key={i}>
+                    {a.label} ({providerLabel(a.provider)})
+                    {existingLabels.has(a.label) && (
+                      <span className="ml-1 text-amber-600 dark:text-amber-400">— {t('transfer.nameExists')}</span>
+                    )}
+                  </li>
+                ))}
+```
+
+Add the warning + chooser just AFTER the preview `<div … aria-live="polite">…</div>` block and BEFORE the `{error !== null && …}` line:
+
+```tsx
+        {collisions.length > 0 && (
+          <div className="mt-2">
+            <p className="text-xs text-amber-600 dark:text-amber-400">{t('transfer.duplicateWarning', { count: collisions.length })}</p>
+            <label className="mt-1 block text-sm">
+              {t('transfer.duplicateMode')}
+              <select
+                aria-label={t('transfer.duplicateMode')}
+                className="mt-1 block w-full rounded border border-slate-300 px-2 py-1 text-sm dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100"
+                value={duplicateMode}
+                onChange={(e) => setDuplicateMode(e.target.value as 'skip' | 'copy' | 'replace')}
+              >
+                <option value="skip">{t('transfer.duplicateSkip')}</option>
+                <option value="copy">{t('transfer.duplicateCopy')}</option>
+                <option value="replace">{t('transfer.duplicateReplace')}</option>
+              </select>
+            </label>
+          </div>
+        )}
+```
+
+- [ ] **Step 5: Run to verify pass**
+
+Run: `npx vitest run src/renderer/components/accounts/ImportAccountsDialog.test.tsx`
+Expected: PASS (existing 5 + 2 new).
+
+- [ ] **Step 6: Full suite + types + lint**
+
+Run: `npm test` (all green), `npx tsc --noEmit` (clean), `npm run lint` (0 errors).
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add src/renderer/i18n/locales/*.json src/renderer/components/accounts/ImportAccountsDialog.tsx src/renderer/components/accounts/ImportAccountsDialog.test.tsx
+git commit -m "feat(accounts): warn and choose skip/copy/replace on name collisions" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+## Self-review notes
+
+- **Spec coverage:** backend onDuplicate skip/copy/replace + snapshot (Task 1); shared Modal with Esc+backdrop (Task 2); 10 dialogs adopt Modal (Tasks 3+4); import-dialog collision detection from preview + warning + chooser + row marker + onDuplicate wiring + i18n (Task 5). All covered.
+- **Type consistency:** `onDuplicate: 'skip' | 'copy' | 'replace'` identical across channel (Task 1), handler (Task 1), hook (Task 1), and dialog (Task 5). `Modal` props `{ onDismiss, className?, children }` consistent across Tasks 2–4. `deps.accounts.update(id, fields)` matches the `NewAccount` shape.
+- **Backward compatibility:** `onDuplicate` defaults to `'copy'`; existing `accountsImport` tests (call `{ blob }`) and the import-dialog no-collision path are unaffected.
+- **Existing-test impact:** Tasks 3–4 keep dialog content/role/panel classes, so existing dialog tests pass; Task 5 adds `accounts.list` to the import-dialog mock so `useAccounts` resolves.
diff --git a/docs/superpowers/plans/2026-06-16-transfer-dialog-refinements.md b/docs/superpowers/plans/2026-06-16-transfer-dialog-refinements.md
new file mode 100644
index 0000000..c681211
--- /dev/null
+++ b/docs/superpowers/plans/2026-06-16-transfer-dialog-refinements.md
@@ -0,0 +1,743 @@
+# Transfer Dialog Refinements Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Hide the export password field once the string is generated; in import, show the password field only when the blob is encrypted (detected in the background) and add a preview of the accounts to be imported.
+
+**Architecture:** A pure `peekEnvelope` reports `encrypted` without decrypting. A new `accountsImportPreview` IPC dry-runs the import and returns `{ encrypted, accounts: {label,provider}[] | null }` (never secrets). The import dialog debounce-calls it on blob/password change to drive a conditional password field + preview list, gating the Import button.
+
+**Tech Stack:** Electron Forge, TypeScript, `node:crypto`, TanStack Query, react-i18next (6 locales), Vitest + Testing Library.
+
+**Spec:** `docs/superpowers/specs/2026-06-16-transfer-dialog-refinements-design.md`
+
+**Conventions:** `Result<T>` via `ok`/`err`; renderer `unwrap()` throws `"Code: message"`; `errorCode()`/`humanErrorMessage()` in `src/renderer/lib/result.ts`. Tests load real i18n (English). `npx vitest run <path>`, `npx tsc --noEmit`, `npm run lint`. Conventional Commits, footer `Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>`. No pushing. Branch: `feat/account-import-export`.
+
+---
+
+### Task 1: `peekEnvelope` + `ImportPreview` (accountTransfer)
+
+**Files:**
+- Modify: `src/main/accounts/accountTransfer.ts`
+- Modify: `src/main/accounts/accountTransfer.test.ts`
+
+- [ ] **Step 1: Write the failing tests**
+
+Append to `src/main/accounts/accountTransfer.test.ts`:
+
+```ts
+import { peekEnvelope } from './accountTransfer';
+
+describe('peekEnvelope', () => {
+  it('reports encrypted=false for a plain export', () => {
+    const blob = exportAccounts([acc]);
+    expect(peekEnvelope(blob)).toEqual({ encrypted: false });
+  });
+
+  it('reports encrypted=true for a password export', () => {
+    const blob = exportAccounts([acc], 'pw');
+    expect(peekEnvelope(blob)).toEqual({ encrypted: true });
+  });
+
+  it('throws InvalidData on garbage', () => {
+    expect(() => peekEnvelope('!!!nope!!!')).toThrow(expect.objectContaining({ code: 'InvalidData' }));
+  });
+});
+```
+
+(`acc` and `exportAccounts` are already imported/defined at the top of this test file.)
+
+- [ ] **Step 2: Run to verify failure**
+
+Run: `npx vitest run src/main/accounts/accountTransfer.test.ts`
+Expected: FAIL — `peekEnvelope` is not exported.
+
+- [ ] **Step 3: Refactor envelope parsing + add `peekEnvelope` and `ImportPreview`**
+
+In `src/main/accounts/accountTransfer.ts`:
+
+Add this interface after the `ExportAccount` interface:
+
+```ts
+export interface ImportPreview {
+  encrypted: boolean;
+  accounts: { label: string; provider: ProviderId }[] | null;
+}
+```
+
+Add this private helper just above `export function importAccounts` (it extracts the existing base64+JSON+format/version validation):
+
+```ts
+function parseEnvelope(blob: string): Record<string, unknown> {
+  let env: Record<string, unknown>;
+  try {
+    const json = Buffer.from(blob.trim(), 'base64').toString('utf8');
+    const parsed: unknown = JSON.parse(json);
+    if (typeof parsed !== 'object' || parsed === null) throw new Error('not an object');
+    env = parsed as Record<string, unknown>;
+  } catch {
+    throw new TransferError('InvalidData', 'The import data is not valid.');
+  }
+  if (env.format !== FORMAT || env.version !== VERSION || typeof env.data !== 'string') {
+    throw new TransferError('InvalidData', 'The import data is not a recognized account export.');
+  }
+  return env;
+}
+
+/** Report whether an export is password-encrypted, without decrypting it. */
+export function peekEnvelope(blob: string): { encrypted: boolean } {
+  return { encrypted: parseEnvelope(blob).encrypted === true };
+}
+```
+
+In `importAccounts`, replace its inline parse block:
+
+```ts
+  let env: Record<string, unknown>;
+  try {
+    const json = Buffer.from(blob.trim(), 'base64').toString('utf8');
+    const parsed: unknown = JSON.parse(json);
+    if (typeof parsed !== 'object' || parsed === null) throw new Error('not an object');
+    env = parsed as Record<string, unknown>;
+  } catch {
+    throw new TransferError('InvalidData', 'The import data is not valid.');
+  }
+  if (env.format !== FORMAT || env.version !== VERSION || typeof env.data !== 'string') {
+    throw new TransferError('InvalidData', 'The import data is not a recognized account export.');
+  }
+```
+
+with:
+
+```ts
+  const env = parseEnvelope(blob);
+```
+
+(Everything after this line in `importAccounts` is unchanged.)
+
+- [ ] **Step 4: Run to verify pass**
+
+Run: `npx vitest run src/main/accounts/accountTransfer.test.ts`
+Expected: PASS (existing 13 + 3 new). The existing importAccounts tests still pass — `parseEnvelope` does exactly what the inline block did.
+
+- [ ] **Step 5: Lint + commit**
+
+Run: `npm run lint` (0 errors), then:
+
+```bash
+git add src/main/accounts/accountTransfer.ts src/main/accounts/accountTransfer.test.ts
+git commit -m "feat(accounts): add peekEnvelope and ImportPreview type" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 2: `accountsImportPreview` IPC
+
+**Files:**
+- Modify: `src/main/ipc/channels.ts`, `src/main/ipc/register.ts`, `src/preload.ts`, `src/main/ipc/register.test.ts`
+
+- [ ] **Step 1: Add the failing handler tests**
+
+In `src/main/ipc/register.test.ts`, add inside `describe('registerIpc', …)`:
+
+```ts
+  it('accounts:importPreview returns label+provider (no secret) for a plain export', async () => {
+    const { exportAccounts } = await import('../accounts/accountTransfer');
+    const blob = exportAccounts([
+      { label: 'AWS', provider: 'amazon-s3', region: 'eu-central-1', accessKeyId: 'AK', secretAccessKey: 'SECRET' },
+    ]);
+    const { handlers } = buildHarness();
+    const res = (await handlers.get(CH.accountsImportPreview)!({ blob })) as {
+      ok: boolean;
+      data: { encrypted: boolean; accounts: { label: string; provider: string; secretAccessKey?: string }[] | null };
+    };
+    expect(res.ok).toBe(true);
+    expect(res.data.encrypted).toBe(false);
+    expect(res.data.accounts).toEqual([{ label: 'AWS', provider: 'amazon-s3' }]);
+    expect(res.data.accounts![0]).not.toHaveProperty('secretAccessKey');
+  });
+
+  it('accounts:importPreview reports encrypted without a password and previews with one', async () => {
+    const { exportAccounts } = await import('../accounts/accountTransfer');
+    const blob = exportAccounts([
+      { label: 'Enc', provider: 'amazon-s3', region: 'us-east-1', accessKeyId: 'K', secretAccessKey: 'S' },
+    ], 'pw');
+    const { handlers } = buildHarness();
+    const locked = (await handlers.get(CH.accountsImportPreview)!({ blob })) as { ok: boolean; data: { encrypted: boolean; accounts: unknown } };
+    expect(locked).toEqual({ ok: true, data: { encrypted: true, accounts: null } });
+    const opened = (await handlers.get(CH.accountsImportPreview)!({ blob, password: 'pw' })) as { ok: boolean; data: { encrypted: boolean; accounts: { label: string }[] } };
+    expect(opened.ok).toBe(true);
+    expect(opened.data.accounts).toEqual([{ label: 'Enc', provider: 'amazon-s3' }]);
+  });
+
+  it('accounts:importPreview errors on a wrong password', async () => {
+    const { exportAccounts } = await import('../accounts/accountTransfer');
+    const blob = exportAccounts([{ label: 'Enc', provider: 'amazon-s3', region: 'us-east-1', accessKeyId: 'K', secretAccessKey: 'S' }], 'pw');
+    const { handlers } = buildHarness();
+    const res = (await handlers.get(CH.accountsImportPreview)!({ blob, password: 'WRONG' })) as { ok: boolean; error: { code: string } };
+    expect(res.ok).toBe(false);
+    expect(res.error.code).toBe('IncorrectPassword');
+  });
+```
+
+- [ ] **Step 2: Run to verify failure**
+
+Run: `npx vitest run src/main/ipc/register.test.ts`
+Expected: FAIL — `CH.accountsImportPreview` undefined.
+
+- [ ] **Step 3: Add the channel (`channels.ts`)**
+
+Add to the existing `import type { ... } from '../accounts/accountTransfer'` line (or add a new import) so `ImportPreview` is imported. If accountTransfer is not yet imported in channels.ts, add:
+
+```ts
+import type { ImportPreview } from '../accounts/accountTransfer';
+```
+
+In `CH`, after `accountsImport: 'accounts:import',`:
+
+```ts
+  accountsImportPreview: 'accounts:importPreview',
+```
+
+In `ApiMap`, after the `[CH.accountsImport]: ...;` line:
+
+```ts
+  [CH.accountsImportPreview]: { args: [{ blob: string; password?: string }]; res: Result<ImportPreview> };
+```
+
+- [ ] **Step 4: Add the handler (`register.ts`)**
+
+The imports `exportAccounts, importAccounts, TransferError` and `type { ExportAccount }` already exist from the account-transfer work. Add `peekEnvelope` to the value import and `ImportPreview` to the type import:
+
+```ts
+import { exportAccounts, importAccounts, TransferError, peekEnvelope } from '../accounts/accountTransfer';
+import type { ExportAccount, ImportPreview } from '../accounts/accountTransfer';
+```
+
+After the `h(CH.accountsImport, …)` handler block, add:
+
+```ts
+  h(CH.accountsImportPreview, (a: { blob: string; password?: string }): Result<ImportPreview> => {
+    let encrypted: boolean;
+    try {
+      encrypted = peekEnvelope(a.blob).encrypted;
+    } catch (e) {
+      if (e instanceof TransferError) return err(e.code, e.message);
+      throw e;
+    }
+    if (encrypted && !a.password) {
+      return ok({ encrypted: true, accounts: null });
+    }
+    let parsed: ExportAccount[];
+    try {
+      parsed = importAccounts(a.blob, a.password);
+    } catch (e) {
+      if (e instanceof TransferError) return err(e.code, e.message);
+      throw e;
+    }
+    return ok({ encrypted, accounts: parsed.map((acc) => ({ label: acc.label, provider: acc.provider })) });
+  });
+```
+
+(`Result` is already imported in register.ts.)
+
+- [ ] **Step 5: Expose in preload (`preload.ts`)**
+
+Inside the `accounts: { … }` object, after the `import:` line:
+
+```ts
+    importPreview: (a: ApiMap[typeof CH.accountsImportPreview]['args'][0]) => invoke(CH.accountsImportPreview, a),
+```
+
+- [ ] **Step 6: Run to verify pass + types + lint**
+
+Run: `npx vitest run src/main/ipc/register.test.ts` (pass). `npx tsc --noEmit` (clean). `npm run lint` (0 errors).
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add src/main/ipc/channels.ts src/main/ipc/register.ts src/preload.ts src/main/ipc/register.test.ts
+git commit -m "feat(ipc): add accounts import preview channel" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 3: `useImportPreview` hook
+
+**Files:**
+- Modify: `src/renderer/hooks/useAccountTransfer.ts`
+- Modify: `src/renderer/hooks/useAccountTransfer.test.tsx`
+
+- [ ] **Step 1: Add the failing test**
+
+In `src/renderer/hooks/useAccountTransfer.test.tsx`, add the import and a describe block:
+
+Change the import line to include the new hook:
+
+```tsx
+import { useExportAccounts, useImportAccounts, useImportPreview } from './useAccountTransfer';
+```
+
+Add inside the `beforeEach` `accounts` mock object a new method:
+
+```tsx
+      importPreview: vi.fn().mockResolvedValue({ ok: true, data: { encrypted: false, accounts: [{ label: 'AWS', provider: 'amazon-s3' }] } }),
+```
+
+Add a describe block:
+
+```tsx
+describe('useImportPreview', () => {
+  it('returns the preview payload', async () => {
+    const { result } = renderHook(() => useImportPreview(), { wrapper: wrapper() });
+    result.current.mutate({ blob: 'BLOB' });
+    await waitFor(() => expect(result.current.data).toEqual({ encrypted: false, accounts: [{ label: 'AWS', provider: 'amazon-s3' }] }));
+  });
+});
+```
+
+- [ ] **Step 2: Run to verify failure**
+
+Run: `npx vitest run src/renderer/hooks/useAccountTransfer.test.tsx`
+Expected: FAIL — `useImportPreview` is not exported.
+
+- [ ] **Step 3: Implement the hook**
+
+In `src/renderer/hooks/useAccountTransfer.ts`, add:
+
+```ts
+export function useImportPreview() {
+  return useMutation({
+    mutationFn: async (input: { blob: string; password?: string }) =>
+      unwrap(await window.s3.accounts.importPreview(input)),
+  });
+}
+```
+
+- [ ] **Step 4: Run to verify pass + lint**
+
+Run: `npx vitest run src/renderer/hooks/useAccountTransfer.test.tsx` (pass). `npx tsc --noEmit` (clean). `npm run lint` (0 errors).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/renderer/hooks/useAccountTransfer.ts src/renderer/hooks/useAccountTransfer.test.tsx
+git commit -m "feat(accounts): add useImportPreview hook" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 4: Export dialog — hide password on the result page
+
+**Files:**
+- Modify: `src/renderer/components/accounts/ExportAccountsDialog.tsx`
+- Modify: `src/renderer/components/accounts/ExportAccountsDialog.test.tsx`
+
+- [ ] **Step 1: Add the failing test**
+
+Append to the `describe('ExportAccountsDialog', …)` block in `src/renderer/components/accounts/ExportAccountsDialog.test.tsx`:
+
+```tsx
+  it('hides the password field once the export string is shown', async () => {
+    wrap(<ExportAccountsDialog accountIds={['a']} onClose={() => {}} />);
+    expect(screen.getByLabelText('Password (optional)')).toBeInTheDocument();
+    await userEvent.click(screen.getByRole('button', { name: 'Generate export' }));
+    await screen.findByLabelText('Export string');
+    expect(screen.queryByLabelText('Password (optional)')).not.toBeInTheDocument();
+  });
+```
+
+- [ ] **Step 2: Run to verify failure**
+
+Run: `npx vitest run src/renderer/components/accounts/ExportAccountsDialog.test.tsx`
+Expected: FAIL — the password field is still present after generating.
+
+- [ ] **Step 3: Move the password field into the input phase**
+
+In `src/renderer/components/accounts/ExportAccountsDialog.tsx`, replace this block:
+
+```tsx
+        <label className="block text-sm">
+          {t('transfer.password')}
+          <input type="password" className={field} value={password} onChange={(e) => setPassword(e.target.value)} />
+        </label>
+        {password.length === 0 && (
+          <p className="mt-2 text-xs text-amber-600 dark:text-amber-400">{t('transfer.noPasswordWarning')}</p>
+        )}
+
+        {result === null ? (
+          <div className="mt-4 flex justify-end">
+            <button
+              type="button"
+              disabled={exportAccounts.isPending}
+              className="rounded bg-slate-800 px-3 py-1 text-sm text-white hover:bg-slate-700 disabled:opacity-40 dark:bg-slate-200 dark:text-slate-900"
+              onClick={onGenerate}
+            >
+              {t('transfer.generate')}
+            </button>
+          </div>
+        ) : (
+```
+
+with:
+
+```tsx
+        {result === null ? (
+          <>
+            <label className="block text-sm">
+              {t('transfer.password')}
+              <input type="password" className={field} value={password} onChange={(e) => setPassword(e.target.value)} />
+            </label>
+            {password.length === 0 && (
+              <p className="mt-2 text-xs text-amber-600 dark:text-amber-400">{t('transfer.noPasswordWarning')}</p>
+            )}
+            <div className="mt-4 flex justify-end">
+              <button
+                type="button"
+                disabled={exportAccounts.isPending}
+                className="rounded bg-slate-800 px-3 py-1 text-sm text-white hover:bg-slate-700 disabled:opacity-40 dark:bg-slate-200 dark:text-slate-900"
+                onClick={onGenerate}
+              >
+                {t('transfer.generate')}
+              </button>
+            </div>
+          </>
+        ) : (
+```
+
+(The `: ( … )` result branch with the textarea + Copy/Download stays unchanged.)
+
+- [ ] **Step 4: Run to verify pass + lint**
+
+Run: `npx vitest run src/renderer/components/accounts/ExportAccountsDialog.test.tsx` (pass, 5 tests). `npx tsc --noEmit` (clean). `npm run lint` (0 errors).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/renderer/components/accounts/ExportAccountsDialog.tsx src/renderer/components/accounts/ExportAccountsDialog.test.tsx
+git commit -m "feat(accounts): hide export password field after generating" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+### Task 5: Import dialog — conditional password + preview
+
+**Files:**
+- Modify: `src/renderer/i18n/locales/{en,de,fr,pl,nl,ro}.json`
+- Modify: `src/renderer/components/accounts/ImportAccountsDialog.tsx`
+- Modify: `src/renderer/components/accounts/ImportAccountsDialog.test.tsx`
+
+- [ ] **Step 1: Add three i18n keys to the `transfer` object in all six locales**
+
+| Key | en | de |
+| --- | --- | --- |
+| previewCount | {{count}} accounts will be imported | {{count}} Konten werden importiert |
+| encryptedHint | Encrypted — enter the password to preview | Verschlüsselt — Passwort zur Vorschau eingeben |
+| checking | Checking… | Wird geprüft… |
+
+| Key | fr | pl |
+| --- | --- | --- |
+| previewCount | {{count}} comptes seront importés | Zostanie zaimportowanych {{count}} kont |
+| encryptedHint | Chiffré — saisissez le mot de passe pour prévisualiser | Zaszyfrowane — wprowadź hasło, aby wyświetlić podgląd |
+| checking | Vérification… | Sprawdzanie… |
+
+| Key | nl | ro |
+| --- | --- | --- |
+| previewCount | {{count}} accounts worden geïmporteerd | {{count}} conturi vor fi importate |
+| encryptedHint | Versleuteld — voer het wachtwoord in voor een voorbeeld | Criptat — introdu parola pentru previzualizare |
+| checking | Controleren… | Se verifică… |
+
+Validate JSON: `node -e "['en','de','fr','pl','nl','ro'].forEach(l=>JSON.parse(require('fs').readFileSync('src/renderer/i18n/locales/'+l+'.json','utf8')))"`.
+
+- [ ] **Step 2: Rewrite the test file (failing first)**
+
+Replace the FULL contents of `src/renderer/components/accounts/ImportAccountsDialog.test.tsx`:
+
+```tsx
+import { describe, it, expect, beforeEach, vi, type Mock } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { ReactNode } from 'react';
+import { ToastProvider } from '../ui/ToastProvider';
+import { ImportAccountsDialog } from './ImportAccountsDialog';
+
+function wrap(node: ReactNode) {
+  const client = new QueryClient({ defaultOptions: { mutations: { retry: false } } });
+  return render(
+    <QueryClientProvider client={client}>
+      <ToastProvider>{node}</ToastProvider>
+    </QueryClientProvider>,
+  );
+}
+
+function setS3(over: Record<string, unknown> = {}) {
+  (window as unknown as { s3: unknown }).s3 = {
+    accounts: {
+      import: vi.fn().mockResolvedValue({ ok: true, data: [{ id: 'n1' }] }),
+      importPreview: vi.fn().mockResolvedValue({ ok: true, data: { encrypted: false, accounts: [{ label: 'AWS prod', provider: 'amazon-s3' }] } }),
+      ...over,
+    },
+    openTextFile: vi.fn().mockResolvedValue({ ok: true, data: 'FILE-BLOB' }),
+  };
+}
+
+beforeEach(() => setS3());
+
+describe('ImportAccountsDialog', () => {
+  it('previews an unencrypted blob: shows the list, no password field, import enabled', async () => {
+    wrap(<ImportAccountsDialog onClose={() => {}} onImported={() => {}} />);
+    await userEvent.type(screen.getByLabelText('Import data'), 'BLOB');
+    expect(await screen.findByText('AWS prod (Amazon S3)')).toBeInTheDocument();
+    expect(screen.queryByLabelText('Password')).not.toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Import' })).toBeEnabled();
+  });
+
+  it('imports after previewing and reports the count', async () => {
+    const onImported = vi.fn();
+    const onClose = vi.fn();
+    wrap(<ImportAccountsDialog onClose={onClose} onImported={onImported} />);
+    await userEvent.type(screen.getByLabelText('Import data'), 'BLOB');
+    await screen.findByText('AWS prod (Amazon S3)');
+    await userEvent.click(screen.getByRole('button', { name: 'Import' }));
+    await screen.findByText('AWS prod (Amazon S3)'); // settle
+    expect(window.s3.accounts.import).toHaveBeenCalledWith({ blob: 'BLOB', password: undefined });
+    expect(onImported).toHaveBeenCalled();
+    expect(onClose).toHaveBeenCalled();
+  });
+
+  it('shows the password field for an encrypted blob and previews after the password', async () => {
+    setS3({
+      importPreview: vi.fn().mockImplementation(async (input: { password?: string }) =>
+        input.password
+          ? { ok: true, data: { encrypted: true, accounts: [{ label: 'Hetzner', provider: 'hetzner' }] } }
+          : { ok: true, data: { encrypted: true, accounts: null } },
+      ),
+    });
+    wrap(<ImportAccountsDialog onClose={() => {}} onImported={() => {}} />);
+    await userEvent.type(screen.getByLabelText('Import data'), 'ENC');
+    const pw = await screen.findByLabelText('Password');
+    expect(screen.getByRole('button', { name: 'Import' })).toBeDisabled();
+    await userEvent.type(pw, 'secret');
+    expect(await screen.findByText('Hetzner (Hetzner Object Storage)')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Import' })).toBeEnabled();
+  });
+
+  it('shows an inline error on an incorrect password and keeps Import disabled', async () => {
+    setS3({
+      importPreview: vi.fn().mockImplementation(async (input: { password?: string }) =>
+        input.password
+          ? { ok: false, error: { code: 'IncorrectPassword', message: 'Incorrect password.' } }
+          : { ok: true, data: { encrypted: true, accounts: null } },
+      ),
+    });
+    wrap(<ImportAccountsDialog onClose={() => {}} onImported={() => {}} />);
+    await userEvent.type(screen.getByLabelText('Import data'), 'ENC');
+    const pw = await screen.findByLabelText('Password');
+    await userEvent.type(pw, 'wrong');
+    expect(await screen.findByText('Incorrect password.')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Import' })).toBeDisabled();
+  });
+
+  it('loads a file into the textarea', async () => {
+    wrap(<ImportAccountsDialog onClose={() => {}} onImported={() => {}} />);
+    await userEvent.click(screen.getByRole('button', { name: 'Load file' }));
+    expect(await screen.findByDisplayValue('FILE-BLOB')).toBeInTheDocument();
+  });
+});
+```
+
+- [ ] **Step 3: Run to verify failure**
+
+Run: `npx vitest run src/renderer/components/accounts/ImportAccountsDialog.test.tsx`
+Expected: FAIL — no preview list / password field is always shown.
+
+- [ ] **Step 4: Rewrite the dialog**
+
+Replace the FULL contents of `src/renderer/components/accounts/ImportAccountsDialog.tsx`:
+
+```tsx
+import { useEffect, useRef, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { FiX } from 'react-icons/fi';
+import { useImportAccounts, useImportPreview } from '../../hooks/useAccountTransfer';
+import { useToast } from '../ui/ToastProvider';
+import { humanErrorMessage, errorCode } from '../../lib/result';
+import { UI_PROVIDERS } from '../../lib/providers';
+import type { ImportPreview } from '../../../main/accounts/accountTransfer';
+
+// TransferError codes → their localized message keys.
+const CODE_KEYS: Record<string, string> = {
+  IncorrectPassword: 'transfer.incorrectPassword',
+  InvalidData: 'transfer.invalidData',
+};
+
+function providerLabel(provider: string): string {
+  return UI_PROVIDERS.find((p) => p.id === provider)?.label ?? provider;
+}
+
+export function ImportAccountsDialog({ onClose, onImported }: { onClose: () => void; onImported: () => void }) {
+  const { t } = useTranslation();
+  const { show } = useToast();
+  const importAccounts = useImportAccounts();
+  const importPreview = useImportPreview();
+  const [blob, setBlob] = useState('');
+  const [password, setPassword] = useState('');
+  const [encrypted, setEncrypted] = useState(false);
+  const [preview, setPreview] = useState<ImportPreview | null>(null);
+  const [previewError, setPreviewError] = useState<string | null>(null);
+  const [checking, setChecking] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const reqId = useRef(0);
+
+  // Background, debounced preview whenever the blob or password changes.
+  useEffect(() => {
+    if (blob.trim().length === 0) {
+      setPreview(null);
+      setPreviewError(null);
+      setEncrypted(false);
+      setChecking(false);
+      return;
+    }
+    setChecking(true);
+    const id = ++reqId.current;
+    const handle = setTimeout(() => {
+      importPreview
+        .mutateAsync({ blob, password: password || undefined })
+        .then((data) => {
+          if (id !== reqId.current) return;
+          setEncrypted(data.encrypted);
+          setPreview(data);
+          setPreviewError(null);
+        })
+        .catch((e) => {
+          if (id !== reqId.current) return;
+          const code = errorCode(e);
+          // A wrong password still means the blob is encrypted — keep the field.
+          if (code === 'IncorrectPassword') setEncrypted(true);
+          else if (code === 'InvalidData') setEncrypted(false);
+          setPreview(null);
+          const key = CODE_KEYS[code ?? ''];
+          setPreviewError(key ? t(key) : humanErrorMessage(e));
+        })
+        .finally(() => {
+          if (id === reqId.current) setChecking(false);
+        });
+    }, 350);
+    return () => clearTimeout(handle);
+    // importPreview.mutateAsync and t are stable; intentionally keyed on blob+password.
+  }, [blob, password]);
+
+  const onLoadFile = async () => {
+    const text = await window.s3.openTextFile();
+    if (text.ok && text.data !== null) setBlob(text.data);
+  };
+
+  const onImport = async () => {
+    setError(null);
+    try {
+      const created = await importAccounts.mutateAsync({ blob, password: password || undefined });
+      show(t('transfer.imported', { count: created.length }));
+      onImported();
+      onClose();
+    } catch (e) {
+      const key = CODE_KEYS[errorCode(e) ?? ''];
+      setError(key ? t(key) : humanErrorMessage(e));
+    }
+  };
+
+  const accounts = preview?.accounts ?? null;
+  const field = 'mt-1 w-full rounded border border-slate-300 px-2 py-1 text-sm dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100';
+
+  return (
+    <div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">
+      <div className="w-[28rem] max-w-[90vw] rounded bg-white p-4 shadow-lg dark:bg-slate-900">
+        <div className="flex items-center justify-between pb-2">
+          <p className="text-sm font-medium text-slate-800 dark:text-slate-100">{t('transfer.importTitle')}</p>
+          <button type="button" aria-label={t('common.close')} className="rounded px-2 hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onClose}>
+            <FiX className="h-4 w-4" aria-hidden />
+          </button>
+        </div>
+
+        <textarea
+          aria-label={t('transfer.pasteAria')}
+          placeholder={t('transfer.pastePlaceholder')}
+          value={blob}
+          onChange={(e) => setBlob(e.target.value)}
+          className="h-24 w-full resize-none rounded border border-slate-300 p-2 font-mono text-xs dark:border-slate-700 dark:bg-slate-800 dark:text-slate-100"
+        />
+        <div className="mt-2">
+          <button type="button" className="rounded border border-slate-300 px-3 py-1 text-sm hover:bg-slate-50 dark:border-slate-700 dark:hover:bg-slate-800" onClick={onLoadFile}>
+            {t('transfer.loadFile')}
+          </button>
+        </div>
+
+        {encrypted && (
+          <label className="mt-3 block text-sm">
+            {t('transfer.importPassword')}
+            <input type="password" className={field} value={password} onChange={(e) => setPassword(e.target.value)} />
+          </label>
+        )}
+
+        <div className="mt-3 text-sm" aria-live="polite">
+          {checking && <span className="text-slate-500 dark:text-slate-400">{t('transfer.checking')}</span>}
+          {!checking && previewError !== null && <span className="text-red-600 dark:text-red-400">{previewError}</span>}
+          {!checking && previewError === null && encrypted && accounts === null && (
+            <span className="text-slate-500 dark:text-slate-400">{t('transfer.encryptedHint')}</span>
+          )}
+          {!checking && accounts !== null && (
+            <div>
+              <p className="text-slate-700 dark:text-slate-200">{t('transfer.previewCount', { count: accounts.length })}</p>
+              <ul className="mt-1 max-h-32 overflow-auto text-slate-600 dark:text-slate-300">
+                {accounts.map((a, i) => (
+                  <li key={i}>{a.label} ({providerLabel(a.provider)})</li>
+                ))}
+              </ul>
+            </div>
+          )}
+        </div>
+
+        {error !== null && <p className="mt-2 text-xs text-red-600 dark:text-red-400">{error}</p>}
+
+        <div className="mt-4 flex justify-end gap-2">
+          <button type="button" className="rounded px-3 py-1 text-sm hover:bg-slate-100 dark:hover:bg-slate-800" onClick={onClose}>
+            {t('common.cancel')}
+          </button>
+          <button
+            type="button"
+            disabled={accounts === null || importAccounts.isPending}
+            className="rounded bg-slate-800 px-3 py-1 text-sm text-white hover:bg-slate-700 disabled:opacity-40 dark:bg-slate-200 dark:text-slate-900"
+            onClick={onImport}
+          >
+            {t('transfer.import')}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
+```
+
+- [ ] **Step 5: Run to verify pass + types + lint**
+
+Run: `npx vitest run src/renderer/components/accounts/ImportAccountsDialog.test.tsx` (pass, 5 tests). `npx tsc --noEmit` (clean). `npm run lint` (0 errors).
+
+- [ ] **Step 6: Full suite**
+
+Run: `npm test` (all green), `npx tsc --noEmit` (clean), `npm run lint` (0 errors).
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add src/renderer/i18n/locales/*.json src/renderer/components/accounts/ImportAccountsDialog.tsx src/renderer/components/accounts/ImportAccountsDialog.test.tsx
+git commit -m "feat(accounts): import preview with conditional password field" -m "Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+```
+
+---
+
+## Self-review notes
+
+- **Spec coverage:** export password hidden on result (Task 4); `peekEnvelope` (Task 1); `accountsImportPreview` returning label+provider with no secrets (Task 2); `useImportPreview` (Task 3); debounced background preview + conditional password + preview list + gated import + i18n (Task 5). All covered.
+- **Type consistency:** `ImportPreview { encrypted: boolean; accounts: {label,provider}[] | null }` defined in Task 1, used in channels (Task 2), hook (Task 3), dialog (Task 5). `accountsImportPreview` arg `{ blob, password? }` consistent across channel/handler/preload/hook/dialog. `errorCode`/`humanErrorMessage`/`CODE_KEYS` reused from existing code.
+- **No-secret guarantee:** the preview handler maps to `{ label, provider }` only; a Task-2 test asserts the result has no `secretAccessKey`.
+- **Debounce staleness:** guarded by the `reqId` token so a stale resolve can't overwrite a newer one.
+- **Existing tests:** Task 1 keeps `importAccounts` behavior (extraction only). Task 5 fully replaces the import-dialog test file (the old tests assumed an always-visible password field + immediate import).
diff --git a/docs/superpowers/specs/2026-06-16-account-transfer-design.md b/docs/superpowers/specs/2026-06-16-account-transfer-design.md
new file mode 100644
index 0000000..693bb54
--- /dev/null
+++ b/docs/superpowers/specs/2026-06-16-account-transfer-design.md
@@ -0,0 +1,165 @@
+# Account import / export — design
+
+## Summary
+
+Let users export one, several, or all S3 accounts to a portable string
+(optionally password-encrypted) and import accounts from such a string or a
+saved file. Export is reachable per-account and as "export all" from the
+Accounts (Connections) screen; import lives there too. The export bundle carries
+each account's metadata **and its secret access key**, so the password
+encryption is the protective layer.
+
+## Decisions made
+
+- **Scope:** per-account export (a row action) **and** "export all" (header
+  button); import accepts a pasted string **or** a loaded file.
+- **Password optional.** With a password the bundle is encrypted; without one,
+  the secret keys are only base64-encoded (not encrypted) — the export dialog
+  shows a clear warning in that case. (User explicitly wanted the password
+  optional.)
+- **Crypto:** scrypt KDF (random salt) → AES-256-GCM (random IV, auth tag). The
+  GCM tag detects both tampering and a wrong password.
+- **Import is all-or-nothing** and always creates **new** account ids (no silent
+  overwrite; duplicates are possible if the same bundle is imported twice).
+- **No new npm dependency** — uses `node:crypto`. File read/write goes through
+  injected main-process helpers (mirrors the existing `saveDialog`).
+
+## Data shapes
+
+```ts
+// One account in the bundle — exactly what accountsCreate needs (no id/createdAt).
+interface ExportAccount {
+  label: string;
+  provider: ProviderId;
+  region: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  endpoint?: string;
+  forcePathStyle?: boolean;
+}
+
+// The decoded envelope (the export string is base64 of JSON.stringify(envelope)).
+interface ExportEnvelope {
+  format: 's3manager-accounts';
+  version: 1;
+  encrypted: boolean;
+  // present only when encrypted:
+  kdf?: { name: 'scrypt'; N: number; r: number; p: number; salt: string /*base64*/ };
+  cipher?: 'aes-256-gcm';
+  iv?: string;  // base64
+  tag?: string; // base64
+  // encrypted: base64 ciphertext of JSON.stringify({ accounts });
+  // plaintext: JSON.stringify({ accounts })
+  data: string;
+}
+```
+
+scrypt params: `N=32768, r=8, p=1`, keylen 32; salt 16 bytes; GCM iv 12 bytes.
+
+## Components
+
+### Pure module `src/main/accounts/accountTransfer.ts`
+
+No Electron, no fs — only `node:crypto`. Exports:
+
+- `exportAccounts(accounts: ExportAccount[], password?: string): string`
+  — builds `{ accounts }`, wraps in an `ExportEnvelope` (encrypting when a
+  non-empty password is given), returns `base64(JSON.stringify(envelope))`.
+- `importAccounts(blob: string, password?: string): ExportAccount[]`
+  — base64-decodes, parses the envelope, validates `format`/`version`; if
+  `encrypted` and no password → throw `PasswordRequired`; decrypts (GCM failure
+  → `IncorrectPassword`); parses and returns `accounts`. Malformed input →
+  `InvalidData`. Errors are thrown as `Error` with a stable `.code`
+  (`'PasswordRequired' | 'IncorrectPassword' | 'InvalidData'`) so handlers map
+  them to `err(code, message)`.
+
+### Main — IPC handlers + file helpers
+
+New `RegisterDeps`:
+- `saveTextFile: (defaultName: string, contents: string) => Promise<boolean>`
+  (true = saved, false = cancelled).
+- `openTextFile: () => Promise<string | null>` (file text, or null if cancelled).
+
+`main.ts` wires them with `dialog.showSaveDialog` + `fs.writeFile` and
+`dialog.showOpenDialog({ properties: ['openFile'] })` + `fs.readFile`.
+
+New channels:
+- `accountsExport: { args: [{ accountIds: string[]; password?: string }]; res: Result<string> }`
+  — for each id: `accounts.get(id)` + `secrets.get(id)`; skip ids with no
+  account; if a selected account's secret can't be read → `err`. Build
+  `ExportAccount[]`, call `exportAccounts`, return the string.
+- `accountsImport: { args: [{ blob: string; password?: string }]; res: Result<Account[]> }`
+  — `importAccounts(blob, password)`; validate every provider is known and
+  resolve conn params (reuse the existing create-path validation); then in **one
+  `db.transaction`** create each account + `secrets.set`. Return the created
+  accounts. Any validation failure → `err` before writing anything.
+- `saveTextFile: { args: [{ defaultName: string; contents: string }]; res: Result<{ saved: boolean }> }`
+- `openTextFile: { args: []; res: Result<string | null> }`
+
+`preload.ts` exposes all four.
+
+### Renderer
+
+- Hooks `src/renderer/hooks/useAccountTransfer.ts`: `useExportAccounts()` and
+  `useImportAccounts()` mutations (the latter invalidates the accounts query on
+  success). Plus thin wrappers for `saveTextFile` / `openTextFile` used by the
+  dialogs.
+- `ExportAccountsDialog({ accountIds, onClose })` — optional password field;
+  "Generate" → `accountsExport` → shows the result in a readonly textarea with
+  **Copy** and **Download** (`saveTextFile`, default name
+  `s3manager-accounts.txt`). Shows the no-password warning when the field is
+  empty.
+- `ImportAccountsDialog({ onClose, onImported })` — paste textarea + **Load
+  file** (`openTextFile` fills the textarea) + optional password field;
+  "Import" → `accountsImport`. On `PasswordRequired`/`IncorrectPassword`, show an
+  inline message asking for (or correcting) the password and keep the dialog
+  open. On success: toast "N imported", call `onImported`, close.
+
+### `ConnectionsScreen` entry points
+
+- Header (list view): existing "Add account" plus **Import** and **Export all**
+  (the latter disabled when there are zero accounts).
+- Each account row: a new **Export** icon button alongside edit/remove, opening
+  `ExportAccountsDialog` with that single id.
+
+## Error handling & edge cases
+
+- Encryption unavailable (`secrets.get` can't decrypt) → export `err` with a
+  clear message.
+- Import of an unknown provider or invalid endpoint → `err`, nothing created.
+- Wrong/missing password → mapped error surfaced inline in the import dialog.
+- Empty selection / empty paste → button disabled.
+- Tampered ciphertext → GCM failure → `IncorrectPassword` (we don't distinguish
+  tamper from wrong key; both mean "can't decrypt").
+
+## i18n
+
+New keys in all six locales for both dialogs and the entry-point buttons
+(generate, copy, download, password, no-password warning, paste, load file,
+import, "N imported", error messages, export/import/export-all labels and aria).
+
+## Testing (TDD)
+
+- `accountTransfer.test.ts`: round-trip with and without password; wrong
+  password → `IncorrectPassword`; encrypted blob + no password →
+  `PasswordRequired`; non-base64 / wrong-format / wrong-version → `InvalidData`;
+  tampered ciphertext → `IncorrectPassword`; multi-account round-trip.
+- `register.test.ts`: `accountsExport` returns a string that decodes to the
+  selected account incl. its secret (stub secrets); `accountsImport` creates the
+  accounts + secrets (assert repo + secrets state) and is all-or-nothing on a
+  bad provider; `saveTextFile`/`openTextFile` delegate to the injected helpers.
+- `ExportAccountsDialog.test.tsx`: generate shows the string; download calls
+  `saveTextFile`; no-password warning visible/hidden.
+- `ImportAccountsDialog.test.tsx`: paste + import calls `accountsImport`; load
+  file fills the textarea; incorrect-password path shows the inline error.
+- `ConnectionsScreen.test.tsx`: row Export opens the dialog; header Import /
+  Export all open their dialogs; Export all disabled with zero accounts.
+
+## Out of scope
+
+- Cloud sync of accounts; QR codes; key rotation; merging/dedup on import;
+  exporting bucket/sync configuration. Only accounts + their secrets.
+
+## Open questions
+
+None.
diff --git a/docs/superpowers/specs/2026-06-16-duplicate-and-modal-design.md b/docs/superpowers/specs/2026-06-16-duplicate-and-modal-design.md
new file mode 100644
index 0000000..7c3e9e7
--- /dev/null
+++ b/docs/superpowers/specs/2026-06-16-duplicate-and-modal-design.md
@@ -0,0 +1,135 @@
+# Duplicate-name import handling & dismissible modals — design
+
+## Summary
+
+Two independent refinements on the `feat/account-import-export` branch:
+
+1. **Duplicate names on import:** when an imported account's name (label)
+   already exists, warn the user and let them choose, for all collisions at
+   once: **skip**, **import as copies**, or **replace** the existing account.
+2. **Dismissible modals:** every modal in the app closes via **Esc** and via a
+   **backdrop click** (clicking outside the panel), through one shared `Modal`
+   wrapper that all 10 dialogs adopt.
+
+## Decisions made
+
+- **Duplicate options:** one global choice — `skip | copy | replace` — applied
+  to every name collision. `replace` matches by label and updates the existing
+  account (credentials included). Default selection is **skip**.
+- **Backward compatible:** the import IPC's new `onDuplicate` argument defaults
+  to `'copy'` (today's behaviour), so callers that omit it are unchanged.
+- **Modal scope:** all 10 dialogs adopt a shared `ui/Modal` (Export, Import,
+  QuickAdd, CreateBucket, Metadata, Permissions, UploadLink, Move, Name,
+  Confirm). Also resolves the ROADMAP "Escape-to-close" a11y item.
+- **Both parts land on `feat/account-import-export`.**
+
+## Part A — duplicate-name handling
+
+### Backend — `accountsImport` gains `onDuplicate`
+
+- `ApiMap[CH.accountsImport].args` becomes
+  `[{ blob: string; password?: string; onDuplicate?: 'skip' | 'copy' | 'replace' }]`.
+- Handler: parse + validate every provider as today (all-or-nothing). Snapshot
+  `existing = deps.accounts.list()` once. In the single `db.transaction`, for
+  each resolved account, find `dup = existing.find(e => e.label === acc.label)`:
+  - `onDuplicate === 'skip'` and `dup` → skip it.
+  - `onDuplicate === 'replace'` and `dup` → `accounts.update(dup.id, {...fields})`
+    + `secrets.set(dup.id, secret)`; push the updated account.
+  - otherwise (`'copy'`, the default, or no `dup`) → `accounts.create` +
+    `secrets.set`; push the created account.
+  - Return the array of created/updated accounts.
+  - Edge: if several existing accounts share a label, `replace` updates the
+    first match (snapshot order). Documented, acceptable.
+- `useImportAccounts` mutation input type widens to include the optional
+  `onDuplicate`. `preload` already forwards the whole arg object — no change.
+
+### Renderer — `ImportAccountsDialog`
+
+- Read existing accounts via `useAccounts`. From the **preview** list compute
+  collisions: `preview.accounts.filter(a => existingLabels.has(a.label))`.
+- When `collisions.length > 0`:
+  - Show a warning line `transfer.duplicateWarning` ({{count}}).
+  - Show a labelled `<select>` (`transfer.duplicateMode`) with options
+    `transfer.duplicateSkip` / `transfer.duplicateCopy` /
+    `transfer.duplicateReplace`; state `duplicateMode` defaults to `'skip'`.
+  - Mark each colliding row in the preview list with `transfer.nameExists`.
+- Import passes `onDuplicate: collisions.length > 0 ? duplicateMode : 'copy'`.
+- The import still goes through `useImportAccounts` (which invalidates the
+  accounts query), so replaced/created accounts refresh the list.
+
+### i18n (6 locales)
+
+`transfer.duplicateWarning` ("{{count}} names already exist"),
+`transfer.duplicateMode` ("Existing names"), `transfer.duplicateSkip` ("Skip"),
+`transfer.duplicateCopy` ("Import as copies"), `transfer.duplicateReplace`
+("Replace existing"), `transfer.nameExists` ("name exists").
+
+## Part B — shared dismissible `Modal`
+
+### `src/renderer/components/ui/Modal.tsx`
+
+```ts
+function Modal({ onDismiss, className, children }: {
+  onDismiss: () => void;
+  className?: string;       // panel classes (width/padding/bg)
+  children: ReactNode;
+}): JSX.Element
+```
+
+- Renders the overlay `<div className="fixed inset-0 z-10 flex items-center justify-center bg-black/30" role="dialog" aria-modal="true">` with a panel child carrying `className`.
+- **Esc:** a `document` keydown listener (added/removed in an effect) calls
+  `onDismiss` on `Escape`.
+- **Backdrop:** the overlay's `onMouseDown` calls `onDismiss` only when
+  `e.target === e.currentTarget` (the overlay itself, not a child) — so clicks
+  inside the panel never dismiss; no `stopPropagation` needed.
+
+### Refactor the 10 dialogs
+
+Each dialog's hand-rolled
+`<div className="fixed inset-0 … bg-black/30" role="dialog" aria-modal="true"><div className="<panel>">…</div></div>`
+becomes `<Modal onDismiss={<onClose|onCancel>} className="<panel>">…</Modal>`,
+dropping the duplicated overlay/role/aria. `ConfirmDialog` uses `onCancel` as
+`onDismiss`. Panel classes (e.g. `w-80`, `w-96`, `w-[28rem]`) move to the
+`className` prop unchanged. Inner content (headers, FiX buttons, forms) is
+untouched.
+
+Dialogs: `ExportAccountsDialog`, `ImportAccountsDialog`, `QuickAddAccountDialog`,
+`CreateBucketDialog`, `MetadataDialog`, `PermissionsDialog`, `UploadLinkDialog`,
+`MoveDialog`, `NameDialog`, `ConfirmDialog`.
+
+## Error handling & edge cases
+
+- Empty existing list → no collisions → chooser hidden → import `'copy'`.
+- Live DB differs from the preview snapshot (account added meanwhile): the
+  handler re-detects collisions against the live list and is authoritative.
+- Backdrop/Esc dismiss while a dialog has unsaved input or a pending action: the
+  user explicitly asked for this; dismiss = the dialog's existing cancel/close.
+- Existing dialog FiX/Cancel buttons keep working (they call the same handler).
+
+## Testing (TDD)
+
+- `register.test.ts`: `accountsImport` with `onDuplicate` —
+  `skip` (collision skipped, non-colliding created), `copy`/default (duplicate
+  created), `replace` (existing account updated in place + secret replaced, no
+  new row). Assert via `deps.accounts.list()` / `deps.secrets.get`.
+- `Modal.test.tsx`: Esc fires `onDismiss`; backdrop click fires `onDismiss`;
+  a click inside the panel does NOT; renders `role="dialog"` with the panel
+  className.
+- Each refactored dialog's existing test still passes (content + role + buttons
+  unchanged). Add an Esc-closes test to `ConfirmDialog.test.tsx` as a
+  representative.
+- `ImportAccountsDialog.test.tsx`: a preview with a label that matches an
+  existing account shows the warning + chooser and marks the row; importing with
+  the chooser set to `replace` calls `accounts.import` with
+  `onDuplicate: 'replace'`; no collision → no warning, import sends `'copy'`.
+
+## Out of scope
+
+- Per-account duplicate decisions (one global choice only).
+- `aria-labelledby` wiring for dialog titles (separate a11y task).
+- Focus-trapping inside modals (Esc + backdrop only).
+- Deduplicating accounts already in the database.
+
+## Open questions
+
+None.
diff --git a/docs/superpowers/specs/2026-06-16-transfer-dialog-refinements-design.md b/docs/superpowers/specs/2026-06-16-transfer-dialog-refinements-design.md
new file mode 100644
index 0000000..6ad433d
--- /dev/null
+++ b/docs/superpowers/specs/2026-06-16-transfer-dialog-refinements-design.md
@@ -0,0 +1,124 @@
+# Transfer dialog refinements — design
+
+## Summary
+
+Two UX refinements to the account export/import dialogs (built in
+`2026-06-16-account-transfer-design.md`):
+
+1. **Export:** hide the password field (and its no-password warning) once the
+   export string has been generated and is shown — they only belong to the
+   input phase.
+2. **Import:** show the password field only when the pasted/loaded export is
+   actually encrypted (detected in the background), and add an **import
+   preview** — the accounts (label + provider) that will be created, shown
+   before importing. For encrypted exports the preview appears once the correct
+   password is entered.
+
+## Decisions made
+
+- **Encrypted preview = decrypt-then-preview.** For an encrypted export, the
+  password field appears; once the correct password is entered (auto-checked in
+  the background), the decrypted preview list is shown, then the user imports.
+- **Background check, debounced** (~350 ms) on blob/password change — no manual
+  "check" button.
+- **Preview never returns secrets** — only `label` + `provider` per account; no
+  DB writes (pure dry-run).
+- **Import is gated on a valid preview** — the Import button is enabled only when
+  a preview account list is available, so the user only imports what they could
+  preview.
+
+## Components
+
+### Export dialog (`ExportAccountsDialog.tsx`)
+
+Move the password `<label>`/`<input>` and the `noPasswordWarning` paragraph
+inside the `result === null` branch. When `result !== null` (the generated
+string + Copy/Download are shown), neither is rendered. No logic change.
+
+### Backend — `peekEnvelope` (`accountTransfer.ts`)
+
+`export function peekEnvelope(blob: string): { encrypted: boolean }` — base64
+decode + JSON parse + validate `format`/`version`; return `{ encrypted: env.encrypted === true }`.
+Throws `TransferError('InvalidData', …)` on malformed input (reuses the same
+parsing/validation as `importAccounts`).
+
+### Backend — IPC `accountsImportPreview`
+
+- Channel `accountsImportPreview: 'accounts:importPreview'`,
+  `{ args: [{ blob: string; password?: string }]; res: Result<ImportPreview> }`
+  where `interface ImportPreview { encrypted: boolean; accounts: { label: string; provider: ProviderId }[] | null }`.
+- Handler:
+  1. `const { encrypted } = peekEnvelope(blob)` (TransferError → `err(code, message)`).
+  2. If `encrypted && !password` → `ok({ encrypted: true, accounts: null })`.
+  3. Else `const accs = importAccounts(blob, password)` (TransferError →
+     `err`); → `ok({ encrypted, accounts: accs.map(a => ({ label: a.label, provider: a.provider })) })`.
+  - No `accounts.create`, no `secrets.set`, never returns `secretAccessKey`.
+- `preload.ts`: `accounts.importPreview`.
+- `ImportPreview` type lives in `accountTransfer.ts` and is imported into `channels.ts`.
+
+### Renderer — `useImportPreview`
+
+`src/renderer/hooks/useAccountTransfer.ts` gains
+`useImportPreview()` — a mutation calling `unwrap(window.s3.accounts.importPreview(input))`.
+(Mutation, driven by the dialog's debounced effect.)
+
+### Renderer — `ImportAccountsDialog.tsx` rework
+
+State: `blob`, `password`, `preview: ImportPreview | null`, `previewError: string | null`,
+`error: string | null` (import-stage).
+
+- A debounced `useEffect` (~350 ms) on `[blob, password]`: when `blob.trim()` is
+  non-empty, call the preview mutation; on success set `preview`, clear
+  `previewError`; on error set `previewError` (via `humanErrorMessage`/code map →
+  `incorrectPassword`/`invalidData`) and clear `preview`. When `blob` is empty,
+  clear both.
+- **Password field**: rendered only when `preview?.encrypted === true`.
+- **Preview area**:
+  - `preview?.accounts` non-null → `transfer.previewCount` ({{count}}) + a list
+    of `label (provider)`.
+  - `preview?.encrypted && preview.accounts === null` → `transfer.encryptedHint`.
+  - while the debounced check is pending → `transfer.checking`.
+  - `previewError` → inline red message (near the password field when encrypted).
+- **Import button**: disabled unless `preview?.accounts` is non-null and not
+  pending. On click: `useImportAccounts().mutateAsync({ blob, password: password || undefined })`
+  → success toast `transfer.imported` + `onImported()` + `onClose()`; on error set
+  `error` inline (fallback; preview already validated).
+- **Load file** unchanged (fills `blob`, which triggers the debounced preview).
+
+## i18n (6 locales)
+
+New `transfer.*` keys: `previewCount` ("{{count}} accounts will be imported"),
+`encryptedHint` ("Encrypted — enter the password to preview"), `checking`
+("Checking…"). Wrong-password / malformed reuse the existing `incorrectPassword`
+/ `invalidData` keys.
+
+## Error handling & edge cases
+
+- Empty/whitespace blob → no preview call, Import disabled.
+- Malformed blob → `previewError` = invalidData, no password field, Import disabled.
+- Encrypted + wrong password → `previewError` = incorrectPassword, accounts stay
+  null, Import disabled.
+- Switching a blob from encrypted to unencrypted (re-paste) → preview re-runs,
+  password field hides when no longer encrypted.
+- The debounce avoids running scrypt on every keystroke; the latest call wins
+  (ignore stale results — guard with a request token or rely on mutation's latest
+  `data`; the dialog keys preview off the most recent successful call).
+
+## Testing (TDD)
+
+- `accountTransfer.test.ts`: `peekEnvelope` → encrypted true (password export),
+  false (plain export), throws InvalidData on garbage.
+- `register.test.ts`: `accountsImportPreview` — unencrypted returns `{ encrypted:false, accounts:[{label,provider}] }` with NO secret field; encrypted without password → `{ encrypted:true, accounts:null }`; encrypted with correct password → accounts list; wrong password → err; assert the returned objects have no `secretAccessKey`.
+- `useAccountTransfer.test.tsx`: `useImportPreview` returns the preview payload.
+- `ImportAccountsDialog.test.tsx`: paste unencrypted blob → preview list shown, NO password field, Import enabled; paste encrypted blob → password field shown, no list; entering the correct password → list appears and Import enables; wrong password → inline error. (Use fake timers or `findBy*` to let the debounce settle.)
+- `ExportAccountsDialog.test.tsx`: after Generate, the password field is no longer in the document.
+
+## Out of scope
+
+- Per-account selection within an import (all-or-nothing stays).
+- Showing regions/endpoints in the preview (label + provider only).
+- Changing the export bundle format.
+
+## Open questions
+
+None.