Files
Netcatty/infrastructure/services/vaultImportWorkerClient.ts
T
5690442eb3 fix(vault): round-trip jump host chains in CSV import/export (#3827)
* fix(vault): round-trip jump host chains in CSV import/export

CSV export dropped hostChain, so a vault imported on another machine
lost every jump host. Persist the ordered chain as an OpenSSH
ProxyJump column and bind each hop on import.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(vault): drop inline hops from a rejected ProxyJump chain

A self-referential ProxyJump list created unresolved hops before the
chain was skipped, so the import kept those hosts. Discard inline hosts
created for that rejected chain.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(vault): prefer a same-group hop when binding CSV ProxyJump

When an imported host and an existing vault host both match a hop
endpoint, pick the candidate in the target host's group before falling
back to the imported match.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(vault): prefer a same-group label when binding CSV ProxyJump

Combine imported and existing label matches before pickCsvJumpCandidate so a cross-group imported label cannot beat an existing hop in the target group.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(vault): reject CSV ProxyJump chains that contain a malformed hop

A multi-hop ProxyJump cell with any invalid hop now warns and leaves the
host chain unset, instead of saving the valid hops as a shortened route.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

---------

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>
2026-10-21 18:15:09 +08:00

125 lines
3.8 KiB
TypeScript

import type {
VaultImportExistingHostRef,
VaultImportFormat,
VaultImportResult,
} from "../../domain/vaultImport";
import type { VaultImportFileEncoding } from "./vaultImportFile";
export type VaultImportWorkerStage = "reading" | "parsing";
export interface VaultImportWorkerProgress {
stage: VaultImportWorkerStage;
percent: number;
completedFiles?: number;
totalFiles?: number;
currentFileName?: string;
}
export type VaultImportWorkerRequest = {
type: "import";
format: VaultImportFormat;
files: File[];
relativePaths: string[];
encoding: VaultImportFileEncoding | undefined;
masterPassword?: string;
existingHosts?: VaultImportExistingHostRef[];
};
export type VaultImportWorkerResponse =
| { type: "progress"; progress: VaultImportWorkerProgress }
| { type: "result"; result: VaultImportResult }
| { type: "error"; message: string };
type VaultImportWorkerEvent = MessageEvent<VaultImportWorkerResponse> | ErrorEvent;
type VaultImportWorkerListener = (event: VaultImportWorkerEvent) => void;
export interface VaultImportWorkerLike {
addEventListener(type: "message" | "error", listener: VaultImportWorkerListener): void;
removeEventListener(type: "message" | "error", listener: VaultImportWorkerListener): void;
postMessage(message: VaultImportWorkerRequest): void;
terminate(): void;
}
interface ImportVaultHostsInWorkerOptions {
format: VaultImportFormat;
files: File[];
encoding?: VaultImportFileEncoding;
masterPassword?: string;
existingHosts?: readonly VaultImportExistingHostRef[];
signal?: AbortSignal;
createWorker?: () => VaultImportWorkerLike;
onProgress?: (progress: VaultImportWorkerProgress) => void;
}
const createVaultImportWorker = (): VaultImportWorkerLike => (
new Worker(new URL("../workers/vaultImport.worker.ts", import.meta.url), {
type: "module",
})
);
export function importVaultHostsInWorker({
format,
files,
encoding,
masterPassword,
existingHosts,
signal,
createWorker = createVaultImportWorker,
onProgress,
}: ImportVaultHostsInWorkerOptions): Promise<VaultImportResult> {
if (signal?.aborted) {
return Promise.reject(new DOMException("Vault import cancelled.", "AbortError"));
}
const worker = createWorker();
return new Promise((resolve, reject) => {
const cleanup = () => {
worker.removeEventListener("message", handleMessage);
worker.removeEventListener("error", handleWorkerError);
signal?.removeEventListener("abort", handleAbort);
worker.terminate();
};
const handleAbort = () => {
cleanup();
reject(new DOMException("Vault import cancelled.", "AbortError"));
};
const handleMessage: VaultImportWorkerListener = (event) => {
const message = (event as MessageEvent<VaultImportWorkerResponse>).data;
if (message.type === "progress") {
onProgress?.(message.progress);
return;
}
cleanup();
if (message.type === "result") {
resolve(message.result);
return;
}
reject(new Error(message.message));
};
const handleWorkerError: VaultImportWorkerListener = (event) => {
cleanup();
const message = event instanceof ErrorEvent && event.message
? event.message
: "Vault import worker failed.";
reject(new Error(message));
};
worker.addEventListener("message", handleMessage);
worker.addEventListener("error", handleWorkerError);
signal?.addEventListener("abort", handleAbort, { once: true });
worker.postMessage({
type: "import",
format,
files,
relativePaths: files.map((file) => file.webkitRelativePath),
encoding,
...(masterPassword ? { masterPassword } : {}),
...(existingHosts && existingHosts.length > 0 ? { existingHosts: [...existingHosts] } : {}),
});
});
}