@gajae-code/coding-agent 0.13.3 → 0.14.0

package/src/session-import/provider-service.ts

@@ -0,0 +1,457 @@
+import { createHash } from "node:crypto";
+import * as nodeFs from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import { canContinuePersistedHistory } from "@gajae-code/agent-core";
+import { type SessionDestinationInput, SessionManager } from "../session/session-manager";
+import { parseClaudeCodeTranscript, parseClaudeExport } from "./claude";
+import { detectSessionImportFormat } from "./detect";
+import { parseCodexRollout } from "./provider-codex";
+import { IMPORT_SANITIZER_VERSION, redactImportedText } from "./redact";
+import {
+	type ImportedConversation,
+	type ImportQuarantineRecord,
+	type PreparedSessionImport,
+	type SessionImportCompleted,
+	type SessionImportCounts,
+	SessionImportError,
+	type SessionImportProvenance,
+	type SessionImportProviderId,
+} from "./types";
+
+/** Bumped when normalization/rendering changes; persisted in provenance. */
+export const EXTERNAL_IMPORT_CONVERTER_VERSION = 1;
+/** Persisted custom-entry type carrying import provenance (never enters LLM context). */
+export const EXTERNAL_IMPORT_PROVENANCE_CUSTOM_TYPE = "session-import";
+/** Persisted custom-message type carrying the reconstructed continuation context. */
+export const EXTERNAL_IMPORT_CONTEXT_CUSTOM_TYPE = "session-import";
+
+/** Hard source size limit; larger exports fail with `content_too_large`. */
+export const EXTERNAL_IMPORT_SOURCE_MAX_BYTES = 64 * 1024 * 1024;
+const MAX_SOURCE_MESSAGES = 5000;
+const MAX_CONTEXT_CHARS = 120_000;
+const HEAD_CONTEXT_CHARS = 20_000;
+const MAX_MESSAGE_CHARS = 16_000;
+const MAX_TITLE_CHARS = 200;
+const MAX_QUARANTINE_RECORDS = 512;
+
+export interface ExternalSessionImportRequest {
+	/** Explicit user-selected transcript/export file. */
+	sourcePath: string;
+	/** Explicit provider; omitted = deterministic auto-detection. */
+	provider?: SessionImportProviderId;
+	/** Import-owner workspace (recorded as the new session's cwd). */
+	cwd: string;
+	/** Session destination; defaults to the workspace's managed session store. */
+	destination?: SessionDestinationInput;
+	/** Test seam for deterministic provenance timestamps. */
+	now?: () => Date;
+}
+
+interface ParsedSource {
+	conversation: ImportedConversation;
+	quarantine: { present: boolean; truncated: boolean; records: ImportQuarantineRecord[] };
+	counts: SessionImportCounts;
+	redactionKinds: string[];
+}
+
+/** Read the explicit source file with fixed bounds. The source is never written. */
+async function readImportSource(sourcePath: string): Promise<{ text: string; bytes: number; sha256: string }> {
+	const resolved = path.resolve(sourcePath);
+	const displayPath = redactImportedText(sourcePath).value;
+	let handle: fsp.FileHandle;
+	try {
+		handle = await fsp.open(resolved, nodeFs.constants.O_RDONLY | nodeFs.constants.O_NOFOLLOW);
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code === "ENOENT") {
+			throw new SessionImportError("source_not_found", "read", `Transcript file does not exist: ${displayPath}`);
+		}
+		throw new SessionImportError(
+			"source_unreadable",
+			"read",
+			`Transcript file cannot be read (${code ?? "unknown error"}): ${displayPath}`,
+			{ retryable: true },
+		);
+	}
+	try {
+		const initial = await handle.stat({ bigint: true });
+		if (!initial.isFile()) {
+			throw new SessionImportError(
+				"invalid_request",
+				"read",
+				`Import source must be a regular file, not a directory or special file: ${displayPath}`,
+			);
+		}
+		if (initial.size === 0n) {
+			throw new SessionImportError("malformed_input", "parse", `Transcript file is empty: ${displayPath}`);
+		}
+		if (initial.size > BigInt(EXTERNAL_IMPORT_SOURCE_MAX_BYTES)) {
+			throw new SessionImportError(
+				"content_too_large",
+				"read",
+				`Transcript is ${initial.size} bytes, exceeding the ${EXTERNAL_IMPORT_SOURCE_MAX_BYTES}-byte import limit. Export a shorter session or trim the file.`,
+				{ limitBytes: EXTERNAL_IMPORT_SOURCE_MAX_BYTES, observedBytes: Number(initial.size) },
+			);
+		}
+		const bytes = Buffer.alloc(Number(initial.size));
+		let offset = 0;
+		while (offset < bytes.length) {
+			const read = await handle.read(bytes, offset, bytes.length - offset, offset);
+			if (read.bytesRead === 0) break;
+			offset += read.bytesRead;
+		}
+		if (offset !== bytes.length) {
+			throw new SessionImportError(
+				"source_changed",
+				"read",
+				"The transcript file changed while it was being read.",
+				{
+					retryable: true,
+				},
+			);
+		}
+		const terminal = await handle.stat({ bigint: true });
+		if (
+			terminal.dev !== initial.dev ||
+			terminal.ino !== initial.ino ||
+			terminal.nlink !== initial.nlink ||
+			terminal.size !== initial.size ||
+			terminal.mtimeNs !== initial.mtimeNs ||
+			terminal.ctimeNs !== initial.ctimeNs
+		) {
+			throw new SessionImportError(
+				"source_changed",
+				"read",
+				"The transcript file changed while it was being read. Re-export or retry with a stable file.",
+				{ retryable: true },
+			);
+		}
+		return {
+			text: bytes.toString("utf8"),
+			bytes: bytes.length,
+			sha256: createHash("sha256").update(bytes).digest("hex"),
+		};
+	} catch (error) {
+		if (error instanceof SessionImportError) throw error;
+		const code = (error as NodeJS.ErrnoException).code;
+		throw new SessionImportError(
+			"source_unreadable",
+			"read",
+			`Transcript file cannot be read (${code ?? "unknown error"}): ${displayPath}`,
+			{ retryable: true },
+		);
+	} finally {
+		await handle.close().catch(() => {});
+	}
+}
+
+function parseDetectedFormat(detection: ReturnType<typeof detectSessionImportFormat>, text: string): ParsedSource {
+	switch (detection.format) {
+		case "codex-rollout-jsonl":
+			return normalizeAdapterResult(parseCodexRollout(text));
+		case "claude-code-jsonl":
+			return normalizeAdapterResult(parseClaudeCodeTranscript(text));
+		case "claude-export-json":
+			return normalizeAdapterResult(parseClaudeExport(text));
+	}
+}
+
+function normalizeAdapterResult(result: {
+	conversation: ImportedConversation;
+	quarantine: ImportQuarantineRecord[];
+	counts: SessionImportCounts;
+	redactionKinds: string[];
+}): ParsedSource {
+	return {
+		conversation: result.conversation,
+		quarantine: {
+			present: result.quarantine.length > 0,
+			truncated: result.counts.quarantined > result.quarantine.length,
+			records: result.quarantine.slice(0, MAX_QUARANTINE_RECORDS),
+		},
+		counts: result.counts,
+		redactionKinds: result.redactionKinds,
+	};
+}
+
+function assertValidTimestamps(conversation: ImportedConversation): void {
+	for (const message of conversation.messages) {
+		if (message.timestamp === undefined) continue;
+		if (!Number.isFinite(Date.parse(message.timestamp))) {
+			throw new SessionImportError(
+				"malformed_input",
+				"normalize",
+				"A message carries an unparseable timestamp; the transcript is not a clean export.",
+			);
+		}
+	}
+}
+
+function truncateText(text: string, maxChars: number): string {
+	if (text.length <= maxChars) return text;
+	return `${text.slice(0, maxChars - 1)}…`;
+}
+
+/** Render the bounded continuation context document (head + tail with an elision marker). */
+function renderImportContext(conversation: ImportedConversation): {
+	text: string;
+	omitted: number;
+	truncated: boolean;
+} {
+	const titleLine = conversation.title ? ` titled "${truncateText(conversation.title, MAX_TITLE_CHARS)}"` : "";
+	const lines: string[] = [
+		`<imported-session provider="${conversation.provider}" format="${conversation.format}">`,
+		"",
+		`The conversation below was imported from an external ${conversation.provider === "codex" ? "Codex" : "Claude"} session transcript${titleLine}.`,
+		"It is reconstructed context only: roles and text are preserved, but tool/internal provider state was not cloned, and secrets were redacted.",
+		"Continue this conversation naturally as its current participant.",
+		"",
+	];
+	if (conversation.cwd) lines.push(`Original workspace: ${conversation.cwd}`, "");
+
+	const rendered: string[] = [];
+	for (const message of conversation.messages) {
+		const speaker = message.role === "user" ? "User" : "Assistant";
+		const blocks: string[] = [];
+		if (message.text) blocks.push(truncateText(message.text, MAX_MESSAGE_CHARS));
+		if (message.toolEvidence && message.toolEvidence.length > 0) {
+			blocks.push(["Tool/file evidence:", ...message.toolEvidence.map(line => `  ${line}`)].join("\n"));
+		}
+		if (blocks.length === 0) continue;
+		rendered.push(`### ${speaker}\n\n${blocks.join("\n\n")}`);
+	}
+
+	let omitted = 0;
+	let truncated = false;
+	let body: string[];
+	if (rendered.length === 0) {
+		body = [];
+	} else {
+		const chars = rendered.reduce((total, part) => total + part.length + 2, 0);
+		if (chars <= MAX_CONTEXT_CHARS) {
+			body = rendered;
+		} else {
+			truncated = true;
+			const head: string[] = [];
+			let headChars = 0;
+			while (head.length < rendered.length && headChars + rendered[head.length]!.length + 2 <= HEAD_CONTEXT_CHARS) {
+				headChars += rendered[head.length]!.length + 2;
+				head.push(rendered[head.length]!);
+			}
+			const tail: string[] = [];
+			let tailChars = 0;
+			for (let index = rendered.length - 1; index >= head.length; index--) {
+				const part = rendered[index]!;
+				if (tailChars + part.length + 2 > MAX_CONTEXT_CHARS - headChars) break;
+				tailChars += part.length + 2;
+				tail.unshift(part);
+			}
+			omitted = rendered.length - head.length - tail.length;
+			body = [
+				...head,
+				`[… ${omitted} earlier message${omitted === 1 ? "" : "s"} from the imported ${conversation.provider} session were elided to bound context; the continuation tail is preserved below. …]`,
+				...tail,
+			];
+		}
+	}
+
+	lines.push(...body);
+	lines.push("", "</imported-session>");
+	return { text: lines.join("\n"), omitted, truncated };
+}
+
+/**
+ * Phase 1: read, detect, parse, normalize, redact, and bound. Performs no
+ * session mutation; safe to run before any session transition.
+ */
+export async function prepareExternalSessionImport(
+	request: Pick<ExternalSessionImportRequest, "sourcePath" | "provider">,
+): Promise<PreparedSessionImport> {
+	if (typeof request.sourcePath !== "string" || request.sourcePath.trim().length === 0) {
+		throw new SessionImportError(
+			"invalid_request",
+			"request",
+			"A transcript file path is required: /import-session <file> [--provider codex|claude]",
+		);
+	}
+	if (request.provider !== undefined && request.provider !== "codex" && request.provider !== "claude") {
+		throw new SessionImportError(
+			"invalid_request",
+			"request",
+			`Unsupported provider "${String(request.provider)}"; expected codex or claude.`,
+		);
+	}
+	const source = await readImportSource(request.sourcePath);
+	const detection = detectSessionImportFormat(source.text, request.provider);
+	const parsed = parseDetectedFormat(detection, source.text);
+	assertValidTimestamps(parsed.conversation);
+
+	if (parsed.conversation.messages.length === 0) {
+		throw new SessionImportError(
+			"malformed_input",
+			"parse",
+			`No importable user/assistant messages were found in the ${detection.format} transcript.`,
+		);
+	}
+	if (parsed.conversation.messages.length > MAX_SOURCE_MESSAGES) {
+		throw new SessionImportError(
+			"content_too_large",
+			"normalize",
+			`The transcript has ${parsed.conversation.messages.length} messages, exceeding the ${MAX_SOURCE_MESSAGES}-message import limit. Export a shorter session.`,
+			{ limitBytes: MAX_SOURCE_MESSAGES, observedBytes: parsed.conversation.messages.length },
+		);
+	}
+
+	const rendered = renderImportContext(parsed.conversation);
+	const counts: SessionImportCounts = { ...parsed.counts, omitted: rendered.omitted };
+	const provenance: PreparedSessionImport["provenance"] = {
+		schemaVersion: 1,
+		customType: EXTERNAL_IMPORT_PROVENANCE_CUSTOM_TYPE,
+		provider: parsed.conversation.provider,
+		format: parsed.conversation.format,
+		sourceFileName: redactImportedText(path.basename(path.resolve(request.sourcePath))).value.slice(0, 255),
+		...(parsed.conversation.sourceSessionId ? { sourceSessionId: parsed.conversation.sourceSessionId } : {}),
+		...(parsed.conversation.title ? { sourceTitle: truncateText(parsed.conversation.title, MAX_TITLE_CHARS) } : {}),
+		sourceSha256: source.sha256,
+		sourceBytes: source.bytes,
+		converterVersion: EXTERNAL_IMPORT_CONVERTER_VERSION,
+		sanitizerVersion: IMPORT_SANITIZER_VERSION,
+		counts,
+		truncated: rendered.truncated,
+		quarantine: parsed.quarantine,
+	};
+	return {
+		conversation: parsed.conversation,
+		contextText: rendered.text,
+		provenance,
+		counts,
+		redactionKinds: parsed.redactionKinds,
+		sourcePath: path.resolve(request.sourcePath),
+		sourceSha256: source.sha256,
+		sourceBytes: source.bytes,
+	};
+}
+
+/**
+ * Phase 2: materialize a prepared import as a NEW GJC session file and verify
+ * it reopens as a resumable session. The caller's live session is untouched.
+ */
+export async function materializeExternalSessionImport(
+	prepared: PreparedSessionImport,
+	options: Pick<ExternalSessionImportRequest, "cwd" | "destination" | "now">,
+): Promise<SessionImportCompleted> {
+	if (typeof options.cwd !== "string" || options.cwd.length === 0) {
+		throw new SessionImportError("invalid_request", "request", "A workspace cwd is required to host the import.");
+	}
+	const importedAt = (options.now?.() ?? new Date()).toISOString();
+	const manager = SessionManager.create(options.cwd, options.destination);
+	const destination = manager.getDestinationForFork();
+	const sessionFile = manager.getSessionFile();
+	if (!sessionFile) {
+		await manager.close().catch(() => {});
+		throw new SessionImportError(
+			"io_failed",
+			"persist",
+			"Session persistence is unavailable for this workspace; the import has nowhere to live.",
+		);
+	}
+	const targetSessionId = manager.getSessionId();
+	try {
+		const provenance: SessionImportProvenance = {
+			...prepared.provenance,
+			targetSessionId,
+			importedAt,
+		};
+		manager.appendCustomEntry(EXTERNAL_IMPORT_PROVENANCE_CUSTOM_TYPE, provenance);
+		manager.appendCustomMessageEntry(
+			EXTERNAL_IMPORT_CONTEXT_CUSTOM_TYPE,
+			prepared.contextText,
+			true,
+			{
+				provider: prepared.conversation.provider,
+				format: prepared.conversation.format,
+				sourceSha256: prepared.sourceSha256,
+				sourceBytes: prepared.sourceBytes,
+				counts: prepared.counts,
+				truncated: prepared.provenance.truncated,
+				importedAt,
+			},
+			"agent",
+		);
+		const title =
+			prepared.conversation.title ??
+			`Imported ${prepared.conversation.provider === "codex" ? "Codex" : "Claude"} session ${(
+				prepared.conversation.sourceSessionId ?? prepared.sourceSha256
+			).slice(0, 8)}`;
+		await manager.setSessionName(truncateText(title, MAX_TITLE_CHARS), "user");
+		await manager.ensureOnDisk();
+		await manager.flush();
+
+		// Verify the written file reopens cleanly and is continuable before the
+		// caller switches to it. Keep the creating manager open so its captured
+		// managed destination authority remains valid throughout verification;
+		// closing it afterward releases that authority exactly once.
+		const reopened = await SessionManager.open(sessionFile, destination);
+		try {
+			if (!canContinuePersistedHistory(reopened.buildSessionContext().messages)) {
+				throw new SessionImportError(
+					"malformed_input",
+					"persist",
+					"The imported session did not reconstruct a continuable conversation.",
+				);
+			}
+		} finally {
+			await reopened.close().catch(() => {});
+		}
+		await manager.close();
+		return { targetSessionId, targetPath: sessionFile, title: truncateText(title, MAX_TITLE_CHARS), prepared };
+	} catch (error) {
+		await manager.close().catch(() => {});
+		if (error instanceof SessionImportError) throw error;
+		const message = error instanceof Error ? error.message : String(error);
+		throw new SessionImportError("io_failed", "persist", `Failed to persist the imported session: ${message}`, {
+			retryable: true,
+		});
+	}
+}
+
+/** Full import: prepare + materialize. Never switches the caller's session. */
+export async function importProviderSessionFile(
+	request: ExternalSessionImportRequest,
+): Promise<SessionImportCompleted> {
+	const prepared = await prepareExternalSessionImport(request);
+	return materializeExternalSessionImport(prepared, request);
+}
+
+/** Human-facing summary lines for a completed import. */
+export function formatProviderSessionImportSummary(result: SessionImportCompleted): string {
+	const { prepared } = result;
+	const providerLabel = prepared.conversation.provider === "codex" ? "Codex" : "Claude";
+	const lines = [
+		`Imported ${providerLabel} session (${prepared.conversation.format}) into a new GJC session.`,
+		`Session: ${result.targetSessionId}`,
+		`Title: ${result.title}`,
+		`Messages: ${prepared.conversation.messages.length} reconstructed (${prepared.counts.mapped} records mapped, ${prepared.counts.quarantined} quarantined)`,
+		`Source: ${prepared.provenance.sourceFileName} (${prepared.sourceBytes} bytes, sha256 ${prepared.sourceSha256.slice(0, 12)}…)`,
+	];
+	if (prepared.counts.omitted > 0) {
+		lines.push(`Bounded: ${prepared.counts.omitted} earlier messages elided between the preserved head and tail.`);
+	}
+	if (prepared.counts.redacted > 0) {
+		lines.push(
+			`Redacted: ${prepared.counts.redacted} secret/credential value${prepared.counts.redacted === 1 ? "" : "s"} (${prepared.redactionKinds.join(", ")}).`,
+		);
+	}
+	lines.push("The original transcript file was not modified.");
+	return lines.join("\n");
+}
+
+/** Human-facing diagnostic for a failed import. */
+export function formatProviderSessionImportError(error: unknown): string {
+	if (error instanceof SessionImportError) {
+		const retry = error.retryable ? " (retryable)" : "";
+		return `Import failed: ${error.code} [${error.phase}]${retry} — ${error.message}`;
+	}
+	return `Import failed: ${error instanceof Error ? error.message : String(error)}`;
+}

package/src/session-import/redact.ts

@@ -0,0 +1,128 @@
+/**
+ * Fail-closed secret redaction for imported session content (issue #3709).
+ *
+ * Every string that crosses the import boundary passes through
+ * {@link redactImportedText}. Patterns are conservative: a false positive costs
+ * one `[REDACTED]` span in reconstructed context, a false negative leaks a
+ * credential into a new session transcript, so the balance favors redaction.
+ */
+
+export const IMPORT_REDACTED_PLACEHOLDER = "[REDACTED]";
+/** Bumped when patterns change; persisted in import provenance. */
+export const IMPORT_SANITIZER_VERSION = 2;
+
+const ANSI_ESCAPE = /\x1b(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1b\\))/gu;
+const UNSAFE_CONTROL =
+	/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f\u200b-\u200f\u202a-\u202e\u2060\u2066-\u2069\ufeff]/gu;
+const HEADER_CREDENTIAL = /(\b(?:authorization|cookie|set-cookie)\b[ \t]*:[ \t]*)([^\r\n]*)/giu;
+const JSON_AUTHORIZATION = /((?:\\?")authorization(?:\\?")\s*:\s*(?:\\?")?)([^",}\r\n]+)/giu;
+
+interface RedactionRule {
+	readonly id: string;
+	readonly pattern: RegExp;
+}
+
+const HEX = "[0-9a-fA-F]";
+
+/**
+ * Ordered first-match-wins rules. Each rule replaces its full match with the
+ * placeholder, so a matched credential never survives partially.
+ */
+const REDACTION_RULES: readonly RedactionRule[] = [
+	// PEM private-key blocks, header through footer.
+	{
+		id: "pem-private-key",
+		pattern: /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g,
+	},
+	// AWS access key ids.
+	{ id: "aws-access-key", pattern: /(?:AKIA|ASIA|ABIA|ACCA)[0-9A-Z]{16}/g },
+	// GitHub tokens (PAT, OAuth, server-to-server, refresh, fine-grained).
+	{ id: "github-token", pattern: /(?:ghp|gho|ghu|ghs|ghr|github_pat)_[A-Za-z0-9_]{20,}/g },
+	// Anthropic API keys.
+	{ id: "anthropic-key", pattern: /sk-ant-[A-Za-z0-9_-]{20,}/g },
+	// OpenAI-style keys (project keys, service accounts, legacy sk-).
+	{ id: "openai-key", pattern: /sk-(?:proj|svcacct|admin)-[A-Za-z0-9_-]{20,}|sk-[A-Za-z0-9]{20,}/g },
+	// Slack tokens.
+	{ id: "slack-token", pattern: /xox[baprs]-[A-Za-z0-9-]{10,}/g },
+	// Google API keys.
+	{ id: "google-api-key", pattern: /AIza[0-9A-Za-z_-]{35}/g },
+	// Bearer tokens carried in Authorization text.
+	{
+		id: "bearer-token",
+		pattern: /(authorization["'\s]*[:=]["'\s]*bearer\s+|bearer\s+)[A-Za-z0-9._~+/=-]{12,}/gi,
+	},
+	// JWTs (three base64url segments; middle segment non-trivial).
+	{
+		id: "jwt",
+		pattern: /eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g,
+	},
+	// Long hex secrets (64+ hex chars: webhook secrets, signing keys).
+	{ id: "hex-secret", pattern: new RegExp(`\\b${HEX}{64,}\\b`, "g") },
+	// Basic-auth credentials embedded in URLs (https://user:pass@host).
+	{ id: "url-credential", pattern: /([a-z][a-z0-9+.-]*:\/\/)[^/\s:@]{1,256}:[^/\s@]{1,256}@/gi },
+	// Sensitive env/KEY assignments: OPENAI_API_KEY=..., token: ..., password = ...
+	// The name prefix is optional so a bare sensitive name (`password: …`) also matches.
+	{
+		id: "secret-assignment",
+		pattern:
+			/\b(?:[A-Za-z_][A-Za-z0-9_]*)?(?:api[_-]?key|secret|token|password|passwd|credential|client[_-]?secret|private[_-]?key|access[_-]?key|refresh[_-]?token|session[_-]?key)[A-Za-z0-9_]*\b(["']?\s*[:=]\s*)("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[^\s,;}&)]{4,})/gi,
+	},
+];
+
+export interface ImportRedactionResult {
+	value: string;
+	redacted: number;
+	kinds: string[];
+}
+
+/**
+ * Redact every known credential shape from imported text. The same placeholder
+ * is used for all kinds so a partial pattern overlap cannot leak fragments.
+ */
+export function redactImportedText(input: string): ImportRedactionResult {
+	let value = input.replace(ANSI_ESCAPE, "").replace(UNSAFE_CONTROL, "");
+	let redacted = 0;
+	const kinds = new Set<string>();
+	value = value.replace(HEADER_CREDENTIAL, (_match, prefix: string, raw: string) => {
+		if (!raw.trim()) return `${prefix}${raw}`;
+		redacted++;
+		kinds.add("credential-header");
+		return `${prefix}${IMPORT_REDACTED_PLACEHOLDER}`;
+	});
+	value = value.replace(JSON_AUTHORIZATION, (_match, prefix: string, raw: string) => {
+		if (!raw.trim()) return `${prefix}${raw}`;
+		redacted++;
+		kinds.add("authorization-json");
+		return `${prefix}${IMPORT_REDACTED_PLACEHOLDER}`;
+	});
+	for (const rule of REDACTION_RULES) {
+		rule.pattern.lastIndex = 0;
+		value = value.replace(rule.pattern, match => {
+			redacted++;
+			kinds.add(rule.id);
+			if (rule.id === "url-credential") {
+				// Keep the scheme visible; the match ends at "@" so the host survives.
+				const schemeEnd = match.indexOf("://") + 3;
+				return `${match.slice(0, schemeEnd)}${IMPORT_REDACTED_PLACEHOLDER}@`;
+			}
+			if (rule.id === "secret-assignment") {
+				const sep = /(["']?\s*[:=]\s*)/.exec(match);
+				if (sep) {
+					const head = match.slice(0, (sep.index ?? 0) + sep[0].length);
+					return `${head}${IMPORT_REDACTED_PLACEHOLDER}`;
+				}
+			}
+			if (rule.id === "bearer-token") {
+				const bearerAt = /bearer\s+/i.exec(match);
+				if (bearerAt) return `${match.slice(0, bearerAt.index + bearerAt[0].length)}${IMPORT_REDACTED_PLACEHOLDER}`;
+			}
+			return IMPORT_REDACTED_PLACEHOLDER;
+		});
+	}
+	return { value, redacted, kinds: [...kinds].sort() };
+}
+
+/** Redact a string, returning only the sanitized value. */
+export function sanitizeImportedString(input: string): string {
+	return redactImportedText(input).value;
+}