@payconductor/houndsman 0.6.0 → 0.8.0

package/src/server/client/utils/types.ts

@@ -83,6 +83,9 @@ export type ArtifactMeta = {
 export type RunSummary = {
 	slug: string;
 	branch: string;
+	/** Worktree onde a run foi executada (ausente = clone principal). */
+	worktreePath?: string;
+	prNumber?: number;
 	updatedAt?: string;
 	startedAt?: string;
 	/** Último sinal de vida de uma execução ativa (revisão/correção). */
@@ -97,6 +100,109 @@ export type FindingsResponse = {
 	summary: Summary;
 };
 
+/** Editor detectado pelo servidor (base dos links de código). */
+export type EditorKind = "vscode" | "jetbrains" | "none";
+
+export type EditorContext = {
+	kind: EditorKind;
+	project?: string;
+	product?: string;
+};
+
+/** Estado da árvore de trabalho (bloqueia o checkout quando suja). */
+export type WorktreeState = {
+	available: boolean;
+	clean: boolean;
+	changes: number;
+	sample: string[];
+};
+
+/** PR aberta exibida na sidebar. */
+export type PrListItem = {
+	number: number;
+	title: string;
+	headRefName: string;
+	baseRefName: string;
+	author: string;
+	updatedAt?: string;
+	isDraft: boolean;
+	reviewDecision?: string;
+	url?: string;
+	runSlug?: string;
+	/** Worktree ativo da PR (revisão paralela). */
+	worktreePath?: string;
+};
+
+export type PrListResponse = {
+	available: boolean;
+	reason?: string;
+	currentBranch: string | null;
+	worktree: WorktreeState;
+	prs: PrListItem[];
+};
+
+export type CheckoutResponse =
+	| { ok: true; number: number; branch: string | null }
+	| {
+			ok: false;
+			reason: "dirty" | "git" | "gh";
+			detail: string;
+			changes?: string[];
+	  };
+
+/** Resultado de `DELETE /api/runs/:slug`. */
+export type DeleteRunResponse = {
+	deleted: boolean;
+	worktreeRequested: boolean;
+	worktreeRemoved: boolean;
+	worktreePath?: string;
+	warning?: string;
+};
+
+export type PrWorktreeResponse =
+	| {
+			ok: true;
+			number: number;
+			branch: string;
+			path: string;
+			head: string;
+			created: boolean;
+			warning?: string;
+	  }
+	| { ok: false; reason: string; detail: string };
+
+/** Comentário normalizado da PR (thread ou geral). */
+export type PrCommentView = {
+	id: number;
+	author: string;
+	authorType: string;
+	body: string;
+	createdAt?: string;
+	url?: string;
+	path?: string;
+	line: number | null;
+	absFile?: string;
+	replyTo?: number | null;
+};
+
+export type PrCommentThread = {
+	id: number;
+	path: string;
+	line: number | null;
+	absFile: string;
+	comments: PrCommentView[];
+};
+
+export type PrCommentsResponse = {
+	available: boolean;
+	reason?: string;
+	target?: { number: number; repo: string; url?: string };
+	fetchedAt: string;
+	threads: PrCommentThread[];
+	issueComments: PrCommentView[];
+	counts: { threads: number; inline: number; issue: number };
+};
+
 /** Manifesto da run (subset consumido pela aba de resumo). */
 export type RunManifest = {
 	branch?: string;
@@ -149,6 +255,8 @@ export type SubmitCandidate = {
 	file: string;
 	line: number | null;
 	severity: Severity;
+	/** Decisão da triagem (`execute` = "a executar"). */
+	decision: Decision;
 	execState: ExecState;
 	rule: string;
 	message: string;

package/src/server/editor.ts

@@ -0,0 +1,129 @@
+/**
+ * Detecção do editor que hospeda o terminal do servidor (biblioteca do servidor).
+ *
+ * VS Code e JetBrains expõem variáveis próprias no terminal integrado. O
+ * contexto alimenta os links de código da UI (`vscode://` / `jetbrains://`).
+ * A detecção é pura e fail-open: sem pistas, o editor fica `none`.
+ */
+
+import { basename, resolve } from "node:path";
+
+/** Editores com esquema de URL próprio. */
+export type EditorKind = "vscode" | "jetbrains" | "none";
+
+/** Contexto usado pelo cliente para montar os links de código. */
+export type EditorContext = {
+	kind: EditorKind;
+	/** Nome do projeto aberto no IDE (basename da raiz do repositório). */
+	project?: string;
+	/** Código do produto JetBrains (`idea`, `webstorm`, `pycharm`…). */
+	product?: string;
+};
+
+type Env = Record<string, string | undefined>;
+
+/** Bundle macOS → código do produto usado no esquema `jetbrains://`. */
+const BUNDLE_PRODUCTS: Record<string, string> = {
+	"com.jetbrains.intellij": "idea",
+	"com.jetbrains.intellij.ce": "idea",
+	"com.jetbrains.pycharm": "pycharm",
+	"com.jetbrains.pycharm.ce": "pycharm",
+	"com.jetbrains.webstorm": "webstorm",
+	"com.jetbrains.goland": "goland",
+	"com.jetbrains.clion": "clion",
+	"com.jetbrains.rider": "rider",
+	"com.jetbrains.phpstorm": "phpstorm",
+	"com.jetbrains.rubymine": "rubymine",
+	"com.jetbrains.datagrip": "datagrip",
+	"com.jetbrains.appcode": "appcode",
+	"com.jetbrains.rustrover": "rustrover",
+};
+
+/** Variáveis `*_INITIAL_DIRECTORY` → produto JetBrains. */
+const DIR_PRODUCTS: [string, string][] = [
+	["IDEA_INITIAL_DIRECTORY", "idea"],
+	["PYCHARM_INITIAL_DIRECTORY", "pycharm"],
+	["WEBSTORM_INITIAL_DIRECTORY", "webstorm"],
+	["GOLAND_INITIAL_DIRECTORY", "goland"],
+	["CLION_INITIAL_DIRECTORY", "clion"],
+	["RIDER_INITIAL_DIRECTORY", "rider"],
+	["PHPSTORM_INITIAL_DIRECTORY", "phpstorm"],
+	["RUBYMINE_INITIAL_DIRECTORY", "rubymine"],
+	["DATAGRIP_INITIAL_DIRECTORY", "datagrip"],
+	["RUSTROVER_INITIAL_DIRECTORY", "rustrover"],
+];
+
+function projectName(repoRoot: string): string {
+	return basename(resolve(repoRoot));
+}
+
+/** Produto JetBrains detectado no ambiente (undefined quando ambíguo). */
+export function detectJetBrainsProduct(env: Env): string | undefined {
+	const bundle = env.__CFBundleIdentifier?.toLowerCase();
+	if (bundle) {
+		const exact = BUNDLE_PRODUCTS[bundle];
+		if (exact) return exact;
+		const prefix = Object.keys(BUNDLE_PRODUCTS).find((key) => bundle.startsWith(key));
+		if (prefix) return BUNDLE_PRODUCTS[prefix];
+	}
+	for (const [name, product] of DIR_PRODUCTS) {
+		if (env[name]) return product;
+	}
+	return undefined;
+}
+
+function isJetBrains(env: Env): boolean {
+	const bundle = env.__CFBundleIdentifier?.toLowerCase() ?? "";
+	return (
+		/jetbrains/i.test(env.TERMINAL_EMULATOR ?? "") ||
+		bundle.startsWith("com.jetbrains.") ||
+		DIR_PRODUCTS.some(([name]) => Boolean(env[name]))
+	);
+}
+
+function isVsCode(env: Env): boolean {
+	return (
+		env.TERM_PROGRAM === "vscode" ||
+		env.TERM_PROGRAM === "vscode-insiders" ||
+		Boolean(env.VSCODE_PID || env.VSCODE_IPC_HOOK_CLI || env.VSCODE_GIT_IPC_HANDLE)
+	);
+}
+
+/** Detecta o editor a partir do ambiente do terminal integrado. */
+export function detectEditor(env: Env, repoRoot: string): EditorContext {
+	const project = projectName(repoRoot);
+	if (isJetBrains(env)) {
+		return {
+			kind: "jetbrains",
+			project,
+			product: detectJetBrainsProduct(env) ?? "idea",
+		};
+	}
+	if (isVsCode(env)) return { kind: "vscode", project };
+	return { kind: "none", project };
+}
+
+/**
+ * Resolve a preferência do `--editor`.
+ *
+ * `auto` (ou ausente) detecta do ambiente; `vscode`/`jetbrains`/`none` forçam
+ * o comportamento. Valores desconhecidos caem na detecção automática.
+ */
+export function resolveEditor(
+	preference: string | undefined,
+	env: Env,
+	repoRoot: string,
+): EditorContext {
+	const value = preference?.trim().toLowerCase();
+	const project = projectName(repoRoot);
+	if (value === "vscode") return { kind: "vscode", project };
+	if (value === "jetbrains") {
+		return {
+			kind: "jetbrains",
+			project,
+			product: detectJetBrainsProduct(env) ?? "idea",
+		};
+	}
+	if (value === "none") return { kind: "none", project };
+	return detectEditor(env, repoRoot);
+}

package/src/server/index.ts

@@ -9,16 +9,23 @@
 import { mediaPath } from "../core/assets";
 import type { HoundsmanConfig } from "../core/config";
 import type { FindingUpdate } from "../core/findings-state";
+import { createGitRunner, type GitRunner } from "../core/git-runner";
 import {
 	defaultGhRunner,
 	type GhRunner,
 	type SubmitSelection,
 } from "../core/github-review";
 import { logger } from "../core/logging";
+import { GitRepository } from "../core/services/git-repository";
+import { PrResolver } from "../core/services/pr-resolver";
+import { WorktreeManager } from "../core/services/worktree-manager";
 import { createStorage } from "../core/storage/factory";
+import { resolveWorktreesRoot } from "../core/storage/paths";
 import { resolveRepoIdentity } from "../core/storage/repo-identity";
 import type { RepoIdentity, StorageProvider } from "../core/storage/types";
 import { buildClientBundle } from "./client-build";
+import { type EditorContext, resolveEditor } from "./editor";
+import { PrInbox } from "./pr-inbox";
 import { RunRepository } from "./run-repository";
 
 type BunServer = ReturnType<typeof Bun.serve>;
@@ -59,8 +66,13 @@ function notFound(detail = "não encontrado"): Response {
 /** Repositório das runs (dados) — ver `run-repository.ts`. */
 type ServerDeps = {
 	ghRunner?: GhRunner;
+	gitRunner?: GitRunner;
 	storage?: StorageProvider;
 	repo?: RepoIdentity;
+	/** Contexto do editor injetado (testes). */
+	editor?: EditorContext;
+	/** Preferência do `--editor` (CLI). */
+	editorPreference?: string;
 };
 
 // ---------------------------------------------------------------------------
@@ -83,6 +95,10 @@ async function route(
 	request: Request,
 	runs: RunRepository,
 	ghRunner: GhRunner,
+	prs: PrInbox,
+	editor: EditorContext,
+	worktrees: WorktreeManager,
+	git: GitRepository,
 ): Promise<Response> {
 	const url = new URL(request.url);
 	const path = url.pathname;
@@ -95,6 +111,75 @@ async function route(
 	}
 	if (path === `/assets/${LOGO_FILE}`) return serveLogo();
 	if (path === "/api/health") return json({ ok: true });
+	if (path === "/api/editor" && request.method === "GET") return json(editor);
+	if (path === "/api/prs" && request.method === "GET") {
+		return json(prs.list(runs.workspaceIndex()));
+	}
+	if (path === "/api/worktrees" && request.method === "GET") {
+		return json({
+			worktrees: worktrees.managed().map((entry) => ({
+				path: entry.path,
+				branch: entry.branch?.replace(/^refs\/heads\//, "") ?? null,
+				head: entry.head ?? null,
+				prunable: entry.prunable,
+			})),
+		});
+	}
+	if (path === "/api/prs/worktree" && request.method === "POST") {
+		const body = (await request.json().catch(() => ({}))) as { number?: unknown };
+		const number = Number(body.number);
+		if (!Number.isInteger(number) || number <= 0) {
+			return json(
+				{ ok: false, reason: "invalid", detail: "Número de PR inválido." },
+				400,
+			);
+		}
+		const resolver = new PrResolver(ghRunner, git);
+		const resolved = resolver.resolve(number);
+		if (!resolved.ok) {
+			return json({ ok: false, reason: resolved.reason, detail: resolved.detail });
+		}
+		const refs = resolver.prepareRefs(resolved.pr);
+		try {
+			const worktree = worktrees.ensure({
+				branch: resolved.pr.headRefName,
+				ref: refs.head,
+			});
+			return json({
+				ok: true,
+				number,
+				branch: resolved.pr.headRefName,
+				path: worktree.path,
+				head: worktree.head,
+				created: worktree.created,
+				warning: refs.warning,
+			});
+		} catch (error) {
+			return json({
+				ok: false,
+				reason: "git",
+				detail: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+	const worktreeMatch = path.match(/^\/api\/worktrees\/(.+)$/);
+	if (worktreeMatch && request.method === "DELETE") {
+		const branch = decodeURIComponent(worktreeMatch[1]);
+		const force = url.searchParams.get("force") === "1";
+		const result = worktrees.remove(branch, { force });
+		return json(result, result.removed ? 200 : 409);
+	}
+	if (path === "/api/prs/checkout" && request.method === "POST") {
+		const body = (await request.json().catch(() => ({}))) as { number?: unknown };
+		const number = Number(body.number);
+		if (!Number.isInteger(number) || number <= 0) {
+			return json(
+				{ ok: false, reason: "invalid", detail: "Número de PR inválido." },
+				400,
+			);
+		}
+		return json(prs.checkout(number));
+	}
 
 	if (path === "/api/runs" && request.method === "GET") {
 		return json({ runs: runs.list() });
@@ -106,8 +191,21 @@ async function route(
 	const rest = match[2] ?? "";
 	if (!runs.exists(slug)) return notFound(`run '${slug}' não encontrada`);
 
+	if (rest === "" && request.method === "DELETE") {
+		const removeWorktree = ["1", "true"].includes(
+			url.searchParams.get("worktree") ?? "",
+		);
+		const result = runs.delete(slug, { removeWorktree });
+		return result ? json(result) : notFound(`run '${slug}' não encontrada`);
+	}
+
 	if (rest === "" || rest === "/") return json(runs.detail(slug));
 
+	if (rest === "/comments" && request.method === "GET") {
+		return json(
+			runs.comments(slug, { refresh: url.searchParams.get("refresh") === "1" }),
+		);
+	}
 	if (rest === "/findings" && request.method === "GET") {
 		return json(runs.findings(slug, url.searchParams));
 	}
@@ -119,6 +217,7 @@ async function route(
 		const body = (await request.json().catch(() => ({}))) as SubmitSelection;
 		const selection: SubmitSelection = {
 			severities: body.severities,
+			decisions: body.decisions,
 			execStates: body.execStates,
 			includeSent: body.includeSent,
 		};
@@ -161,19 +260,46 @@ async function route(
 export class HoundsmanServer {
 	private readonly runs: RunRepository;
 	private readonly ghRunner: GhRunner;
+	private readonly prs: PrInbox;
+	private readonly editor: EditorContext;
+	private readonly worktrees: WorktreeManager;
+	private readonly git: GitRepository;
 
 	constructor(config: HoundsmanConfig, deps: ServerDeps = {}) {
+		const repo = deps.repo ?? resolveRepoIdentity();
+		this.ghRunner = deps.ghRunner ?? defaultGhRunner;
+		this.git = new GitRepository(deps.gitRunner ?? createGitRunner(repo.root));
+		this.prs = new PrInbox(this.ghRunner, this.git);
+		this.worktrees = new WorktreeManager(
+			new GitRepository(createGitRunner(repo.root)),
+			{
+				repoKey: repo.key,
+				repoRoot: repo.root,
+				baseDir: resolveWorktreesRoot(config.worktrees?.location, repo.root),
+			},
+		);
 		this.runs = new RunRepository(
 			deps.storage ?? createStorage(config),
-			deps.repo ?? resolveRepoIdentity(),
+			repo,
+			this.ghRunner,
+			this.worktrees,
 		);
-		this.ghRunner = deps.ghRunner ?? defaultGhRunner;
+		this.editor =
+			deps.editor ?? resolveEditor(deps.editorPreference, process.env, repo.root);
 	}
 
 	/** Handler de requisições (testável sem abrir porta). */
 	readonly handler = async (request: Request): Promise<Response> => {
 		try {
-			return await route(request, this.runs, this.ghRunner);
+			return await route(
+				request,
+				this.runs,
+				this.ghRunner,
+				this.prs,
+				this.editor,
+				this.worktrees,
+				this.git,
+			);
 		} catch (error) {
 			return json(
 				{ error: error instanceof Error ? error.message : String(error) },
@@ -223,17 +349,26 @@ export type ServerOptions = {
 	host?: string;
 	/** Runner do `gh` (injetável nos testes). */
 	ghRunner?: GhRunner;
+	/** Runner do git (injetável nos testes). */
+	gitRunner?: GitRunner;
 	/** Provider/storage injetável (testes). */
 	storage?: StorageProvider;
 	repo?: RepoIdentity;
+	/** Contexto de editor injetado (testes). */
+	editor?: EditorContext;
+	/** Preferência do `--editor` (auto|vscode|jetbrains|none). */
+	editorPreference?: string;
 };
 
 /** Sobe o servidor e devolve a instância + URL. */
 export function startServer(options: ServerOptions): { server: BunServer; url: string } {
 	return new HoundsmanServer(options.config, {
 		ghRunner: options.ghRunner,
+		gitRunner: options.gitRunner,
 		storage: options.storage,
 		repo: options.repo,
+		editor: options.editor,
+		editorPreference: options.editorPreference,
 	}).start({
 		port: options.port,
 		host: options.host,
@@ -295,6 +430,66 @@ code, pre, .mono { font-family:var(--font-mono); tab-size:4; }
 .status-review_done { color:var(--suggestion); }
 .status-fix_done { color:var(--success); }
 .status-timeout { color:var(--blocking); }
+.side-tabs { display:flex; gap:4px; padding:4px; background:var(--surface-2); border:1px solid var(--border); border-radius:999px; }
+.side-tab { flex:1; display:inline-flex; align-items:center; justify-content:center; gap:7px; font:inherit; font-size:12px; font-weight:600; cursor:pointer; color:var(--muted);
+  padding:7px 10px; background:transparent; border:1px solid transparent; border-radius:999px; transition:color .15s ease, background .15s ease; }
+.side-tab:hover { color:var(--fg); }
+.side-tab.active { color:#1b1305; background:linear-gradient(180deg, var(--accent-strong), var(--accent)); }
+.side-count { padding:1px 6px; font-family:var(--font-mono); font-size:10px; color:var(--muted); background:rgba(255,255,255,.08); border-radius:999px; }
+.side-tab.active .side-count { color:#1b1305; background:rgba(0,0,0,.14); }
+.icon-btn { display:inline-grid; place-items:center; width:26px; height:26px; color:var(--muted); background:transparent; border:1px solid var(--border); border-radius:8px; cursor:pointer; text-decoration:none; }
+.icon-btn:hover { color:var(--fg); border-color:var(--border-strong); }
+.icon-btn:disabled { opacity:.5; cursor:not-allowed; }
+.pr-toolbar { display:flex; align-items:center; justify-content:space-between; gap:8px; }
+.pr-toolbar .section-label { margin:0; }
+.prs { display:flex; flex-direction:column; gap:8px; }
+.pr { display:flex; flex-direction:column; gap:7px; padding:11px 12px; background:var(--card); border:1px solid var(--border); border-radius:var(--radius); }
+.pr.current { background:var(--accent-soft); border-color:var(--accent-line); }
+.pr-head { display:flex; align-items:center; gap:7px; font-family:var(--font-mono); font-size:11px; color:var(--muted); }
+.pr-icon { color:var(--muted-2); }
+.pr.current .pr-icon { color:var(--accent); }
+.pr-number { font-weight:600; color:var(--fg); }
+.pr-current { padding:1px 6px; font-size:9px; font-weight:700; letter-spacing:.08em; text-transform:uppercase; color:var(--accent); background:rgba(240,165,44,.12); border-radius:999px; }
+.pr-title { margin:0; font-size:12.5px; font-weight:600; line-height:1.4; word-break:break-word; }
+.pr-meta { display:flex; flex-wrap:wrap; align-items:center; gap:1px 5px; margin:0; font-family:var(--font-mono); font-size:10.5px; color:var(--muted-2); }
+.pr-branch { color:var(--suggestion); }
+.pr-review { margin:0; font-size:10.5px; font-weight:600; }
+.pr-review-APPROVED { color:var(--success); }
+.pr-review-CHANGES_REQUESTED { color:var(--blocking); }
+.pr-review-REVIEW_REQUIRED { color:var(--attention); }
+.pr-actions { display:flex; flex-wrap:wrap; gap:6px; margin-top:2px; }
+.pr-btn { display:inline-flex; align-items:center; gap:5px; font:inherit; font-size:10.5px; font-weight:600; cursor:pointer; padding:4px 9px; color:var(--muted);
+  background:transparent; border:1px solid var(--border-strong); border-radius:999px; text-decoration:none; }
+.pr-btn:hover { color:var(--fg); border-color:var(--accent-line); }
+.pr-btn:disabled { opacity:.45; cursor:not-allowed; }
+.pr-btn.danger { color:var(--accent); background:var(--accent-soft); border-color:var(--accent-line); }
+.pr-warning { margin:0; padding:8px 10px; font-size:11px; line-height:1.5; color:var(--attention);
+  background:rgba(237,161,58,.08); border:1px solid rgba(237,161,58,.24); border-radius:10px; }
+.pr-notice { margin:0; padding:8px 10px; font-size:11px; line-height:1.5; color:var(--success);
+  background:rgba(69,192,122,.08); border:1px solid rgba(69,192,122,.24); border-radius:10px; }
+.pr-current-branch { margin:0; font-family:var(--font-mono); font-size:10.5px; color:var(--muted-2); }
+.pr-current-branch code { color:var(--fg); }
+.comments { display:flex; flex-direction:column; gap:18px; }
+.comments-toolbar { display:flex; align-items:center; justify-content:space-between; gap:12px; }
+.comments-counts { display:flex; flex-wrap:wrap; align-items:center; gap:12px; font-size:11.5px; color:var(--muted); }
+.comments-counts b { font-family:var(--font-mono); font-weight:600; color:var(--fg); }
+.comment-group { display:flex; flex-direction:column; gap:10px; }
+.comment-group-title { margin:0; font-size:11px; font-weight:700; letter-spacing:.16em; text-transform:uppercase; color:var(--muted-2); }
+.comment-file-group { display:flex; flex-direction:column; gap:8px; }
+.comment-group-label { display:flex; align-items:center; gap:8px; margin:0; font-family:var(--font-mono); font-size:11.5px; color:var(--suggestion); }
+.comment-thread { display:flex; flex-direction:column; overflow:hidden; background:var(--card); border:1px solid var(--border); border-radius:var(--radius-lg); }
+.comment-thread-head { display:flex; align-items:center; gap:8px; padding:9px 13px; font-family:var(--font-mono); font-size:11px; color:var(--muted);
+  background:var(--surface-2); border-bottom:1px solid var(--border); }
+.comment-file { overflow:hidden; color:var(--fg); text-overflow:ellipsis; white-space:nowrap; }
+.pr-comment { display:flex; flex-direction:column; gap:7px; padding:12px 14px; border-top:1px solid var(--border); }
+.comment-thread .pr-comment:first-of-type { border-top:0; }
+.pr-comment.reply { margin-left:26px; background:rgba(255,255,255,.012); border-left:2px solid var(--accent-line); }
+.pr-comment-head { display:flex; align-items:center; gap:9px; font-size:11px; color:var(--muted-2); }
+.pr-comment-author { font-size:12px; font-weight:600; color:var(--fg); }
+.pr-comment-link { display:inline-flex; align-items:center; gap:5px; font-size:11px; color:var(--muted); text-decoration:none; }
+.pr-comment-link:hover { color:var(--accent); }
+.pr-comment-body { font-size:12.5px; line-height:1.6; color:#f0ece6; }
+.pr-comment-body .md-p, .pr-comment-body .md-list { font-size:12.5px; }
 .main { flex:1; min-width:0; display:flex; flex-direction:column; overflow-y:auto; }
 .topbar { position:sticky; top:0; z-index:10; display:flex; align-items:center; justify-content:space-between; gap:16px;
   padding:13px 24px; border-bottom:1px solid var(--border); background:rgba(16,16,20,.74);
@@ -314,6 +509,13 @@ code, pre, .mono { font-family:var(--font-mono); tab-size:4; }
   transition:background .15s ease, border-color .15s ease, color .15s ease; }
 .btn:hover { background:#202027; border-color:var(--accent-line); }
 .btn:disabled { opacity:.55; cursor:not-allowed; }
+.btn.danger { color:#ffb3b3; background:rgba(255,86,86,.12); border-color:rgba(255,86,86,.4); }
+.btn.danger:hover { background:rgba(255,86,86,.2); border-color:rgba(255,86,86,.62); }
+.modal-check { display:flex; align-items:flex-start; gap:10px; padding:12px 14px; font-size:12.5px; line-height:1.55;
+  color:var(--fg); background:var(--surface-2); border:1px solid var(--border); border-radius:12px; cursor:pointer; }
+.modal-check input { margin:3px 0 0; flex:none; accent-color:var(--accent); }
+.modal-check code { font-family:var(--font-mono); font-size:11.5px; color:var(--muted); word-break:break-all; }
+.modal-warn { margin:0; font-size:12px; line-height:1.55; color:var(--muted); }
 .icon.spin { animation:spin .8s linear infinite; }
 .content { width:100%; max-width:1180px; margin:0 auto; padding:22px 24px 64px; }
 .page-header { display:flex; align-items:flex-start; justify-content:space-between; gap:18px; margin-bottom:16px; }