revdeck 0.1.0 → 0.2.1

package/dist/cli.js

@@ -47,9 +47,31 @@ function socketPath() {
 function daemonInfoPath() {
   return path.join(stateDir(), "daemon.json");
 }
+function devcontainerBridgeDir() {
+  if (process.env.REVDECK_DEVCONTAINER_DIR) return path.resolve(process.env.REVDECK_DEVCONTAINER_DIR);
+  return path.join(os.homedir(), ".local", "state", "revdeck", "devcontainer");
+}
+function devcontainerRunDir() {
+  return path.join(devcontainerBridgeDir(), "run");
+}
+function devcontainerStateDir() {
+  return path.join(devcontainerBridgeDir(), "state");
+}
+function devcontainerSocketPath() {
+  return path.join(devcontainerRunDir(), "daemon.sock");
+}
 function logPath() {
   return path.join(stateDir(), "daemon.log");
 }
+async function ensureDir(dir, mode = 448) {
+  await mkdir(dir, { recursive: true, mode });
+  const info = await lstat(dir);
+  if (!info.isDirectory()) throw new Error(`${dir}: expected a directory`);
+  if (process.platform !== "win32") {
+    const { chmod } = await import("node:fs/promises");
+    await chmod(dir, mode);
+  }
+}
 async function readTextNoFollow(file, maxBytes = 4 * 1024 * 1024) {
   const info = await lstat(file);
   if (info.isSymbolicLink()) throw new Error(`${path.basename(file)}: symbolic link, read refused`);
@@ -146,7 +168,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "0.1.0";
+    VERSION = "0.2.1";
   }
 });
 
@@ -182,6 +204,19 @@ async function daemonInfo() {
     return null;
   }
 }
+function isDevContainer() {
+  return process.env.REVDECK_DEV_CONTAINER === "1";
+}
+function devcontainerHint() {
+  const runtime = process.env.REVDECK_RUNTIME_DIR ?? "(REVDECK_RUNTIME_DIR)";
+  const state = process.env.REVDECK_STATE_DIR ?? "(REVDECK_STATE_DIR)";
+  return [
+    "\u0434\u0435\u043C\u043E\u043D revdeck \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D \u043D\u0430 \u0445\u043E\u0441\u0442\u0435",
+    "\u043D\u0430 \u0445\u043E\u0441\u0442\u0435: revdeck daemon start",
+    `\u043F\u0440\u043E\u0432\u0435\u0440\u044C\u0442\u0435 mounts \u0438\u0437 revdeck devcontainer --write: ${runtime} \u0438 ${state}`,
+    "gh/glab \u0434\u043E\u043B\u0436\u043D\u044B \u043E\u0441\u0442\u0430\u0432\u0430\u0442\u044C\u0441\u044F \u043D\u0430 \u0445\u043E\u0441\u0442\u0435: \u0432\u043D\u0443\u0442\u0440\u0438 \u043A\u043E\u043D\u0442\u0435\u0439\u043D\u0435\u0440\u0430 \u0438\u0445 \u0437\u0430\u043F\u0443\u0441\u043A\u0430\u0442\u044C \u043D\u0435 \u043D\u0443\u0436\u043D\u043E"
+  ].join("; ");
+}
 async function ensureDaemon(options = {}) {
   const url = process.env.REVDECK_URL;
   if (url) {
@@ -192,9 +227,12 @@ async function ensureDaemon(options = {}) {
   try {
     return { client: await connectSocket(), started: false };
   } catch (error) {
+    if (isDevContainer()) {
+      throw new RpcError(`devcontainer: ${devcontainerHint()}`, "DEVCONTAINER", "revdeck devcontainer --write \u0438 \u043F\u0435\u0440\u0435\u0441\u043E\u0431\u0435\u0440\u0438\u0442\u0435 \u043A\u043E\u043D\u0442\u0435\u0439\u043D\u0435\u0440");
+    }
     if (options.autoStart === false) throw error;
   }
-  await spawnDaemon();
+  await spawnDaemon(options.daemonArgs ?? []);
   const deadline = Date.now() + 15e3;
   let lastError = null;
   while (Date.now() < deadline) {
@@ -211,9 +249,9 @@ async function ensureDaemon(options = {}) {
     "\u0437\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u0435 \u0432\u0440\u0443\u0447\u043D\u0443\u044E: revdeck daemon start --foreground"
   );
 }
-async function spawnDaemon() {
+async function spawnDaemon(extraArgs = []) {
   const entry = daemonEntry();
-  const child = spawn(entry.command, entry.args, {
+  const child = spawn(entry.command, [...entry.args, ...extraArgs], {
     detached: true,
     stdio: "ignore",
     cwd: process.cwd(),
@@ -234,6 +272,11 @@ function daemonEntry() {
   if (existsSync4(sibling)) return { command: process.execPath, args: [sibling] };
   throw new RpcError("\u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D \u0432\u0445\u043E\u0434 \u0434\u0435\u043C\u043E\u043D\u0430 (dist/daemon.js)", "DAEMON");
 }
+function uiBaseUrl(info) {
+  const host = process.env.REVDECK_UI_HOST;
+  if (!isDevContainer() || !host) return info.url;
+  return `http://${host}:${info.port}`;
+}
 async function isDaemonRunning() {
   try {
     const client2 = await connectSocket(void 0, 400);
@@ -1058,10 +1101,10 @@ ${failed.map((item) => `- ${item.id}: ${item.error}`).join("\n")}` : ""),
 
 // src/cli/main.ts
 init_paths();
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile7, stat } from "node:fs/promises";
 import { readFileSync } from "node:fs";
 import { parseArgs } from "node:util";
-import path7 from "node:path";
+import path9 from "node:path";
 
 // src/core/config.ts
 init_paths();
@@ -1134,8 +1177,8 @@ function globToRegExp(glob) {
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function classifyFile(path8) {
-  const lower = path8.toLowerCase();
+function classifyFile(path10) {
+  const lower = path10.toLowerCase();
   if (/(^|\/)(node_modules|dist|build|coverage|vendor)\//.test(lower)) return "generated";
   if (/\.(md|mdx|rst|txt|adoc)$/.test(lower) || /(^|\/)(docs?|adr)\//.test(lower)) return "docs";
   if (/(^|\/)(__tests__|tests?|spec|e2e)\//.test(lower) || /\.(test|spec)\.[cm]?[jt]sx?$/.test(lower) || /_test\.go$/.test(lower)) return "test";
@@ -1556,7 +1599,7 @@ init_format();
 // src/cli/init.ts
 init_paths();
 import { existsSync as existsSync5 } from "node:fs";
-import { appendFile, cp, mkdir as mkdir2, readFile as readFile3, writeFile } from "node:fs/promises";
+import { appendFile, cp, lstat as lstat2, mkdir as mkdir2, readdir, readFile as readFile3, readlink, rm, symlink, writeFile } from "node:fs/promises";
 import path5 from "node:path";
 init_redact();
 init_locale();
@@ -1604,8 +1647,9 @@ async function runInit(rootInput, options) {
   await ensureGitignore(root);
   const adapters = options.adapters.length ? options.adapters : detectAdapters(root);
   const mcp = mcpServer(options.locale);
+  const canonicalSkill = await installSkill(root, options.locale);
   for (const adapter of adapters) {
-    await installAdapter(root, adapter, mcp, options.locale);
+    await installAdapter(root, adapter, mcp, options.locale, canonicalSkill);
   }
   if (!options.noService) {
     writers.out("");
@@ -1618,6 +1662,7 @@ async function runInit(rootInput, options) {
   writers.out(`  revdeck open ${tr("<\u043D\u043E\u043C\u0435\u0440 \u0438\u043B\u0438 \u0441\u0441\u044B\u043B\u043A\u0430>", "<number or URL>")}`);
   writers.out("  revdeck ui");
 }
+var CANONICAL_SKILL = ".agents/skills/revdeck";
 function commandMd(locale2) {
   if (locale2 === "ru") {
     return `---
@@ -1643,10 +1688,10 @@ function commandToml(locale2) {
   return 'description = "Open a MR/PR review and work through the discussion"\nprompt = """Run `revdeck context <number>` (or MCP revdeck_context) and follow the revdeck skill."""\n';
 }
 var SPECS = {
-  agents: { skills: ".agents/skills/revdeck" },
-  dsh: { skills: ".agents/skills/revdeck" },
+  agents: {},
+  dsh: {},
   claude: {
-    skills: ".claude/skills/revdeck",
+    linkSkill: true,
     mcp: ".mcp.json",
     files: [{ path: ".claude/commands/revdeck.md", content: commandMd }]
   },
@@ -1670,25 +1715,13 @@ function detectAdapters(root) {
   if (existsSync5(path5.join(root, ".opencode"))) adapters.add("opencode");
   return [...adapters];
 }
-async function installAdapter(root, adapter, mcp, locale2) {
+async function installAdapter(root, adapter, mcp, locale2, canonicalSkill) {
   const spec = SPECS[adapter];
   if (!spec) {
     writers.err(`! ${tr("\u043D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u044B\u0439 \u0430\u0434\u0430\u043F\u0442\u0435\u0440", "unknown adapter")}: ${adapter} (${Object.keys(SPECS).join(", ")})`);
     return;
   }
-  if (spec.skills) {
-    const skills = path5.join(packageRoot(), "skills", "revdeck", locale2);
-    if (!existsSync5(skills)) {
-      writers.err(`! ${tr("\u043A\u0430\u0442\u0430\u043B\u043E\u0433 skills/revdeck \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: \u043F\u0430\u043A\u0435\u0442 \u0441\u043E\u0431\u0440\u0430\u043D \u043D\u0435 \u043F\u043E\u043B\u043D\u043E\u0441\u0442\u044C\u044E", "skills/revdeck not found: the package is incomplete")}`);
-    } else {
-      const target = path5.join(root, spec.skills);
-      await mkdir2(target, { recursive: true });
-      for (const entry of await skillFiles(skills)) {
-        await cp(path5.join(skills, entry), path5.join(target, entry), { force: true });
-      }
-      writers.out(`\u2714 ${tr("\u0441\u043A\u0438\u043B\u043B", "skill")}: ${path5.relative(root, target)}`);
-    }
-  }
+  if (spec.linkSkill && canonicalSkill) await linkSkill(root, canonicalSkill);
   if (spec.mcp) await mergeMcpJson(path5.join(root, spec.mcp), root, mcp);
   for (const file of spec.files ?? []) {
     const target = path5.join(root, file.path);
@@ -1714,9 +1747,67 @@ async function installAdapter(root, adapter, mcp, locale2) {
     writers.out(`  ${tr("\u041A\u043E\u043C\u0430\u043D\u0434\u0430 /revdeck \u0432 DSH \u043F\u043E\u044F\u0432\u0438\u0442\u0441\u044F \u0438\u0437 \u043F\u043B\u0430\u0433\u0438\u043D\u0430-\u043E\u0431\u0451\u0440\u0442\u043A\u0438; MCP-\u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u044B \u0434\u043E\u0441\u0442\u0443\u043F\u043D\u044B \u0441\u0440\u0430\u0437\u0443.", "A /revdeck command in DSH requires a host plugin; the MCP tools are available immediately.")}`);
   }
 }
-async function skillFiles(dir) {
-  const names = ["SKILL.md", "Review.md", "Feedback.md", "Criteria.md", "Rules.md", "Sources.md"];
-  return names.filter((name) => existsSync5(path5.join(dir, name)));
+async function installSkill(root, locale2) {
+  const source = path5.join(packageRoot(), "skills", "revdeck", locale2);
+  if (!existsSync5(source)) {
+    writers.err(`! ${tr("\u043A\u0430\u0442\u0430\u043B\u043E\u0433 skills/revdeck \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: \u043F\u0430\u043A\u0435\u0442 \u0441\u043E\u0431\u0440\u0430\u043D \u043D\u0435 \u043F\u043E\u043B\u043D\u043E\u0441\u0442\u044C\u044E", "skills/revdeck not found: the package is incomplete")}`);
+    return null;
+  }
+  const target = path5.join(root, CANONICAL_SKILL);
+  await copySkill(source, target);
+  writers.out(`\u2714 ${tr("\u0441\u043A\u0438\u043B\u043B", "skill")}: ${CANONICAL_SKILL}`);
+  return target;
+}
+async function copySkill(source, target) {
+  await mkdir2(target, { recursive: true });
+  for (const entry of await skillFiles(source)) {
+    const file = path5.join(target, entry);
+    await mkdir2(path5.dirname(file), { recursive: true });
+    await cp(path5.join(source, entry), file, { force: true });
+  }
+}
+async function linkSkill(root, canonicalSkill) {
+  const target = path5.join(root, ".claude", "skills", "revdeck");
+  const relative = path5.relative(path5.dirname(target), canonicalSkill);
+  await mkdir2(path5.dirname(target), { recursive: true });
+  const existing = await lstat2(target).catch(() => null);
+  if (existing) {
+    if (existing.isSymbolicLink()) {
+      const current2 = await readlink(target).catch(() => "");
+      if (current2 === relative) {
+        writers.out(`\u2714 ${tr("\u0441\u043A\u0438\u043B\u043B", "skill")}: .claude/skills/revdeck -> ${CANONICAL_SKILL}`);
+        return;
+      }
+      await rm(target, { force: true });
+    } else if (existing.isDirectory() && await isManagedSkillDir(target)) {
+      await rm(target, { recursive: true, force: true });
+    } else {
+      writers.out(`! .claude/skills/revdeck ${tr("\u0443\u0436\u0435 \u0435\u0441\u0442\u044C: \u043D\u0435 \u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0438\u0441\u044B\u0432\u0430\u044E", "already exists: not overwriting")}`);
+      return;
+    }
+  }
+  if (process.platform === "win32") {
+    await copySkill(canonicalSkill, target);
+  } else {
+    await symlink(relative, target, "dir");
+  }
+  writers.out(`\u2714 ${tr("\u0441\u043A\u0438\u043B\u043B", "skill")}: .claude/skills/revdeck -> ${CANONICAL_SKILL}`);
+}
+async function isManagedSkillDir(dir) {
+  const skill = path5.join(dir, "SKILL.md");
+  if (!existsSync5(skill)) return false;
+  const text = await readFile3(skill, "utf8").catch(() => "");
+  return /^name:\s*revdeck\s*$/m.test(text);
+}
+async function skillFiles(dir, prefix = "") {
+  const entries = await readdir(path5.join(dir, prefix), { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const relative = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) files.push(...await skillFiles(dir, relative));
+    else if (entry.isFile()) files.push(relative);
+  }
+  return files.sort();
 }
 async function mergeMcpJson(file, root, mcp) {
   let data = {};
@@ -1802,12 +1893,407 @@ function describeError(error) {
   return redactLine(error instanceof Error ? error.message : error);
 }
 
+// src/cli/eject.ts
+init_paths();
+import { existsSync as existsSync7 } from "node:fs";
+import { lstat as lstat3, readFile as readFile5, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import path7 from "node:path";
+
+// src/core/jsonc.ts
+function parseJsonc(text) {
+  let withoutComments = "";
+  let inString = false;
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (lineComment) {
+      if (char === "\n") {
+        lineComment = false;
+        withoutComments += char;
+      }
+      continue;
+    }
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        blockComment = false;
+        index += 1;
+      } else if (char === "\n") {
+        withoutComments += char;
+      }
+      continue;
+    }
+    if (inString) {
+      withoutComments += char;
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      withoutComments += char;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    withoutComments += char;
+  }
+  let cleaned = "";
+  inString = false;
+  escaped = false;
+  for (let index = 0; index < withoutComments.length; index++) {
+    const char = withoutComments[index];
+    if (inString) {
+      cleaned += char;
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      cleaned += char;
+      continue;
+    }
+    if (char === ",") {
+      let lookahead = index + 1;
+      while (lookahead < withoutComments.length && /\s/.test(withoutComments[lookahead])) lookahead += 1;
+      const next = withoutComments[lookahead];
+      if (next === "}" || next === "]") continue;
+    }
+    cleaned += char;
+  }
+  return JSON.parse(cleaned);
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/cli/eject.ts
+import { applyEdits as applyEdits2, modify as modify2 } from "jsonc-parser";
+
+// src/cli/devcontainer.ts
+init_paths();
+import { existsSync as existsSync6 } from "node:fs";
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
+import path6 from "node:path";
+import { applyEdits, modify, parse as parseJsonc2 } from "jsonc-parser";
+init_locale();
+init_format();
+var CONTAINER_RUNTIME_DIR = "/run/revdeck";
+var CONTAINER_STATE_DIR = "/var/lib/revdeck";
+var CONTAINER_UI_HOST = "host.docker.internal";
+function devcontainerPatch() {
+  const bridge = "${localEnv:HOME}${localEnv:USERPROFILE}/.local/state/revdeck/devcontainer";
+  return {
+    mounts: [
+      { type: "bind", source: `${bridge}/run`, target: CONTAINER_RUNTIME_DIR },
+      { type: "bind", source: `${bridge}/state`, target: CONTAINER_STATE_DIR, readonly: true }
+    ],
+    containerEnv: {
+      REVDECK_RUNTIME_DIR: CONTAINER_RUNTIME_DIR,
+      REVDECK_STATE_DIR: CONTAINER_STATE_DIR,
+      REVDECK_DEV_CONTAINER: "1",
+      REVDECK_UI_HOST: CONTAINER_UI_HOST
+    },
+    remoteEnv: {
+      REVDECK_RUNTIME_DIR: CONTAINER_RUNTIME_DIR,
+      REVDECK_STATE_DIR: CONTAINER_STATE_DIR,
+      REVDECK_DEV_CONTAINER: "1",
+      REVDECK_UI_HOST: CONTAINER_UI_HOST
+    },
+    runArgs: [`--add-host=${CONTAINER_UI_HOST}:host-gateway`]
+  };
+}
+function mergeDevcontainerConfig(existing, patch) {
+  const result = { ...existing };
+  const currentMounts = Array.isArray(existing.mounts) ? [...existing.mounts] : [];
+  for (const mount of patch.mounts) {
+    const index = currentMounts.findIndex((item) => isRecord(item) && item.target === mount.target);
+    if (index >= 0) currentMounts[index] = mount;
+    else currentMounts.push(mount);
+  }
+  result.mounts = currentMounts;
+  const containerEnv = isRecord(existing.containerEnv) ? { ...existing.containerEnv } : {};
+  Object.assign(containerEnv, patch.containerEnv);
+  result.containerEnv = containerEnv;
+  const remoteEnv = isRecord(existing.remoteEnv) ? { ...existing.remoteEnv } : {};
+  Object.assign(remoteEnv, patch.remoteEnv);
+  result.remoteEnv = remoteEnv;
+  const runArgs = Array.isArray(existing.runArgs) ? existing.runArgs.filter((item) => typeof item === "string") : [];
+  for (const arg of patch.runArgs) if (!runArgs.includes(arg)) runArgs.push(arg);
+  result.runArgs = runArgs;
+  return result;
+}
+function applyDevcontainerPatch(text, patch) {
+  let current2 = text;
+  const parsed = parseJsonc2(current2);
+  if (!isRecord(parsed)) throw new Error("devcontainer.json: expected an object");
+  const formatting = { formattingOptions: { insertSpaces: true, tabSize: 2 } };
+  const mounts = Array.isArray(parsed.mounts) ? [...parsed.mounts] : [];
+  for (const mount of patch.mounts) {
+    const index = mounts.findIndex((item) => isRecord(item) && item.target === mount.target);
+    const path10 = ["mounts", index >= 0 ? index : mounts.length];
+    current2 = applyEdits(current2, modify(current2, path10, mount, formatting));
+    if (index >= 0) mounts[index] = mount;
+    else mounts.push(mount);
+  }
+  for (const [key, env] of [
+    ["containerEnv", patch.containerEnv],
+    ["remoteEnv", patch.remoteEnv]
+  ]) {
+    for (const [name, value] of Object.entries(env)) {
+      current2 = applyEdits(current2, modify(current2, [key, name], value, formatting));
+    }
+  }
+  const runArgs = Array.isArray(parsed.runArgs) ? parsed.runArgs.filter((item) => typeof item === "string") : [];
+  for (const arg of patch.runArgs) {
+    if (runArgs.includes(arg)) continue;
+    current2 = applyEdits(current2, modify(current2, ["runArgs", runArgs.length], arg, formatting));
+    runArgs.push(arg);
+  }
+  return current2.endsWith("\n") ? current2 : `${current2}
+`;
+}
+async function runDevcontainer(rootInput, options) {
+  const root = findRepoRoot(rootInput);
+  const patch = devcontainerPatch();
+  await ensureDir(devcontainerRunDir());
+  await ensureDir(devcontainerStateDir());
+  const dir = path6.join(root, ".devcontainer");
+  const file = path6.join(dir, "devcontainer.json");
+  writers.out(tr("\u041C\u043E\u0441\u0442 revdeck \u0434\u043B\u044F \u043A\u043E\u043D\u0442\u0435\u0439\u043D\u0435\u0440\u0430:", "revdeck bridge for the container:"));
+  writers.out(`  ${tr("\u0441\u043E\u043A\u0435\u0442", "socket")}: ${devcontainerRunDir()} -> ${CONTAINER_RUNTIME_DIR}`);
+  writers.out(`  ${tr("\u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435", "state")}: ${devcontainerStateDir()} -> ${CONTAINER_STATE_DIR} (${tr("\u0442\u043E\u043B\u044C\u043A\u043E \u0447\u0442\u0435\u043D\u0438\u0435", "read-only")})`);
+  if (!existsSync6(devcontainerSocketPath())) {
+    writers.err(
+      tr(
+        "! \u0441\u043E\u043A\u0435\u0442 \u043C\u043E\u0441\u0442\u0430 \u0435\u0449\u0451 \u043D\u0435 \u0441\u043E\u0437\u0434\u0430\u043D: \u043D\u0430 \u0445\u043E\u0441\u0442\u0435 \u0432\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u0435 revdeck daemon restart",
+        "! the bridge socket does not exist yet: run revdeck daemon restart on the host"
+      )
+    );
+  }
+  writers.out(tr("\u0412 \u043A\u043E\u043D\u0442\u0435\u0439\u043D\u0435\u0440\u0435: \u0434\u0435\u043C\u043E\u043D, gh \u0438 glab \u043E\u0441\u0442\u0430\u044E\u0442\u0441\u044F \u043D\u0430 \u0445\u043E\u0441\u0442\u0435.", "In the container: the daemon, gh and glab stay on the host."));
+  if (!options.write) {
+    writers.out("");
+    writers.out(tr("\u0424\u0440\u0430\u0433\u043C\u0435\u043D\u0442 \u0434\u043B\u044F .devcontainer/devcontainer.json:", "Snippet for .devcontainer/devcontainer.json:"));
+    writers.out(JSON.stringify(patch, null, 2));
+    writers.out("");
+    writers.out(tr("\u041F\u0440\u0438\u043C\u0435\u043D\u0438\u0442\u044C \u0430\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0438: revdeck devcontainer --write", "Apply automatically: revdeck devcontainer --write"));
+    return;
+  }
+  await mkdir3(dir, { recursive: true });
+  const existed = existsSync6(file);
+  let output;
+  if (existed) {
+    const text = await readFile4(file, "utf8");
+    try {
+      output = applyDevcontainerPatch(text, patch);
+    } catch (error) {
+      throw new Error(
+        tr(
+          `${path6.relative(root, file)}: \u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0440\u0430\u0437\u043E\u0431\u0440\u0430\u0442\u044C JSONC (${error.message}); \u0434\u043E\u0431\u0430\u0432\u044C\u0442\u0435 mounts \u0432\u0440\u0443\u0447\u043D\u0443\u044E`,
+          `${path6.relative(root, file)}: could not parse JSONC (${error.message}); add the mounts manually`
+        )
+      );
+    }
+  } else {
+    const existing = { image: "mcr.microsoft.com/devcontainers/base:bookworm" };
+    output = `${JSON.stringify(mergeDevcontainerConfig(existing, patch), null, 2)}
+`;
+  }
+  await writeFile2(file, output);
+  writers.out(`\u2714 ${path6.relative(root, file)}`);
+  if (existed) writers.out(tr("  \u043A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0438 \u0441\u043E\u0445\u0440\u0430\u043D\u0435\u043D\u044B.", "  comments were preserved."));
+  writers.out("");
+  writers.out(tr("\u0414\u0430\u043B\u044C\u0448\u0435:", "Next:"));
+  writers.out(tr("  1. \u041D\u0430 \u0445\u043E\u0441\u0442\u0435: revdeck daemon restart \u2014 \u043E\u043D \u0441\u043E\u0437\u0434\u0430\u0441\u0442 \u0441\u043E\u043A\u0435\u0442 \u043C\u043E\u0441\u0442\u0430.", "  1. On the host: revdeck daemon restart \u2014 it creates the bridge socket."));
+  writers.out(tr("  2. \u041F\u0435\u0440\u0435\u0441\u043E\u0431\u0435\u0440\u0438\u0442\u0435/\u043F\u0435\u0440\u0435\u043E\u0442\u043A\u0440\u043E\u0439\u0442\u0435 devcontainer.", "  2. Rebuild/reopen the devcontainer."));
+  writers.out(tr("  3. \u0412 \u043A\u043E\u043D\u0442\u0435\u0439\u043D\u0435\u0440\u0435: revdeck doctor \u2014 \u043E\u043D \u043D\u0435 \u0431\u0443\u0434\u0435\u0442 \u0438\u0441\u043A\u0430\u0442\u044C glab/gh \u0432\u043D\u0443\u0442\u0440\u0438.", "  3. In the container: revdeck doctor \u2014 it will not look for glab/gh inside."));
+  writers.out(tr("  \u0414\u043B\u044F UI \u0438\u0437 \u043A\u043E\u043D\u0442\u0435\u0439\u043D\u0435\u0440\u0430 \u0437\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u0435 \u0434\u0435\u043C\u043E\u043D \u043D\u0430 \u0445\u043E\u0441\u0442\u0435 \u0441 --host 0.0.0.0.", "  For the UI from the container, start the daemon on the host with --host 0.0.0.0."));
+}
+
+// src/cli/eject.ts
+init_locale();
+init_format();
+var CONFIG_FILES2 = [".revdeck.yml", ".revdeck.yaml"];
+var COMMAND_FILES = [
+  ".claude/commands/revdeck.md",
+  ".cursor/commands/revdeck.md",
+  ".codex/prompts/revdeck.md",
+  ".gemini/commands/revdeck.toml",
+  ".opencode/command/revdeck.md",
+  ".github/prompts/revdeck.prompt.md"
+];
+var SKILL_DIRS = [".agents/skills/revdeck", ".claude/skills/revdeck"];
+var MCP_FILES = [".mcp.json", ".cursor/mcp.json"];
+async function runEject(rootInput, options) {
+  const root = findRepoRoot(rootInput);
+  const changes = [];
+  const warnings = [];
+  if (!options.keepConfig) {
+    for (const name of CONFIG_FILES2) {
+      const file = path7.join(root, name);
+      if (existsSync7(file)) changes.push({ path: name, action: tr("\u0443\u0434\u0430\u043B\u0438\u0442\u044C \u043A\u043E\u043D\u0444\u0438\u0433", "remove config"), remove: () => rm2(file, { force: true }) });
+    }
+  }
+  for (const name of SKILL_DIRS) {
+    const target = path7.join(root, name);
+    if (!existsSync7(target)) continue;
+    const managed = await isManagedSkill(target);
+    if (!managed) {
+      warnings.push(`${name}: ${tr("\u0441\u043A\u0438\u043B\u043B \u043D\u0435 \u043F\u043E\u0445\u043E\u0436 \u043D\u0430 revdeck \u2014 \u043E\u0441\u0442\u0430\u0432\u043B\u044F\u044E", "does not look like the revdeck skill \u2014 leaving it")}`);
+      continue;
+    }
+    changes.push({ path: name, action: tr("\u0443\u0434\u0430\u043B\u0438\u0442\u044C \u0441\u043A\u0438\u043B\u043B", "remove skill"), remove: () => rm2(target, { recursive: true, force: true }) });
+  }
+  for (const name of COMMAND_FILES) {
+    const file = path7.join(root, name);
+    if (!existsSync7(file)) continue;
+    const text = await readFile5(file, "utf8").catch(() => "");
+    if (!/revdeck/i.test(text)) {
+      warnings.push(`${name}: ${tr("\u0444\u0430\u0439\u043B \u043D\u0435 \u0441\u043E\u0434\u0435\u0440\u0436\u0438\u0442 revdeck \u2014 \u043E\u0441\u0442\u0430\u0432\u043B\u044F\u044E", "file does not mention revdeck \u2014 leaving it")}`);
+      continue;
+    }
+    changes.push({ path: name, action: tr("\u0443\u0434\u0430\u043B\u0438\u0442\u044C \u043A\u043E\u043C\u0430\u043D\u0434\u0443", "remove command"), remove: () => rm2(file, { force: true }) });
+  }
+  for (const name of MCP_FILES) {
+    const file = path7.join(root, name);
+    if (!existsSync7(file)) continue;
+    const text = await readFile5(file, "utf8").catch(() => "");
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch {
+      warnings.push(`${name}: ${tr("\u043D\u0435 JSON \u2014 \u043D\u0435 \u0442\u0440\u043E\u0433\u0430\u044E", "not JSON \u2014 leaving it untouched")}`);
+      continue;
+    }
+    const servers = data.mcpServers;
+    if (!servers || !("revdeck" in servers)) continue;
+    changes.push({
+      path: name,
+      action: tr("\u0443\u0431\u0440\u0430\u0442\u044C MCP-\u0441\u0435\u0440\u0432\u0435\u0440 revdeck", "remove the revdeck MCP server"),
+      remove: async () => {
+        delete servers.revdeck;
+        await writeFile3(file, `${JSON.stringify(data, null, 2)}
+`);
+      }
+    });
+  }
+  const devcontainer = path7.join(root, ".devcontainer", "devcontainer.json");
+  if (existsSync7(devcontainer)) {
+    const text = await readFile5(devcontainer, "utf8");
+    try {
+      const parsed = parseJsonc(text);
+      if (isRecord(parsed)) {
+        const formatting = { formattingOptions: { insertSpaces: true, tabSize: 2 } };
+        let current2 = text;
+        let changed = false;
+        if (Array.isArray(parsed.mounts)) {
+          const mounts = parsed.mounts.filter((item) => !(isRecord(item) && (item.target === CONTAINER_RUNTIME_DIR || item.target === CONTAINER_STATE_DIR)));
+          if (mounts.length !== parsed.mounts.length) {
+            current2 = applyEdits2(current2, modify2(current2, ["mounts"], mounts, formatting));
+            changed = true;
+          }
+        }
+        for (const key of ["containerEnv", "remoteEnv"]) {
+          if (!isRecord(parsed[key])) continue;
+          const env = { ...parsed[key] };
+          for (const name of ["REVDECK_RUNTIME_DIR", "REVDECK_STATE_DIR", "REVDECK_DEV_CONTAINER", "REVDECK_UI_HOST"]) delete env[name];
+          if (Object.keys(env).length !== Object.keys(parsed[key]).length) {
+            current2 = applyEdits2(current2, modify2(current2, [key], env, formatting));
+            changed = true;
+          }
+        }
+        if (Array.isArray(parsed.runArgs)) {
+          const args = parsed.runArgs.filter((item) => item !== "--add-host=host.docker.internal:host-gateway");
+          if (args.length !== parsed.runArgs.length) {
+            current2 = applyEdits2(current2, modify2(current2, ["runArgs"], args, formatting));
+            changed = true;
+          }
+        }
+        if (changed) {
+          const output = current2.endsWith("\n") ? current2 : `${current2}
+`;
+          changes.push({
+            path: ".devcontainer/devcontainer.json",
+            action: tr("\u0443\u0431\u0440\u0430\u0442\u044C \u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u0435 \u043A \u0434\u0435\u043C\u043E\u043D\u0443 \u0445\u043E\u0441\u0442\u0430", "remove the host daemon connection"),
+            remove: () => writeFile3(devcontainer, output)
+          });
+        }
+      }
+    } catch {
+      warnings.push(`.devcontainer/devcontainer.json: ${tr("\u043D\u0435 JSONC \u2014 \u043D\u0435 \u0442\u0440\u043E\u0433\u0430\u044E", "not JSONC \u2014 leaving it untouched")}`);
+    }
+  }
+  const cache = path7.join(root, ".revdeck");
+  if (existsSync7(cache)) {
+    changes.push({ path: ".revdeck/", action: tr("\u0443\u0434\u0430\u043B\u0438\u0442\u044C \u043B\u043E\u043A\u0430\u043B\u044C\u043D\u044B\u0439 \u043A\u0435\u0448", "remove local cache"), remove: () => rm2(cache, { recursive: true, force: true }) });
+  }
+  const gitignore = path7.join(root, ".gitignore");
+  if (existsSync7(gitignore)) {
+    const text = await readFile5(gitignore, "utf8");
+    if (/(^|\n)\.revdeck\/?\s*(\n|$)/.test(text)) {
+      changes.push({
+        path: ".gitignore",
+        action: tr("\u0443\u0431\u0440\u0430\u0442\u044C \u0441\u0442\u0440\u043E\u043A\u0443 .revdeck/", "remove the .revdeck/ line"),
+        remove: async () => {
+          const next = text.split("\n").filter((line) => line.trim() !== ".revdeck/" && line.trim() !== ".revdeck").join("\n");
+          await writeFile3(gitignore, next);
+        }
+      });
+    }
+  }
+  if (!changes.length) {
+    writers.out(tr("\u0432 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0438 \u043D\u0435\u0442 \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u043D\u043E\u0433\u043E revdeck", "revdeck is not installed in this repository"));
+    for (const warning of warnings) writers.err(`! ${warning}`);
+    return;
+  }
+  writers.out(tr("\u0411\u0443\u0434\u0435\u0442 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u043E:", "Will change:"));
+  for (const change of changes) writers.out(`  ${change.action}: ${change.path}`);
+  for (const warning of warnings) writers.err(`! ${warning}`);
+  if (!options.yes) {
+    writers.out("");
+    writers.out(tr("\u041D\u0438\u0447\u0435\u0433\u043E \u043D\u0435 \u0443\u0434\u0430\u043B\u0435\u043D\u043E: \u0434\u043E\u0431\u0430\u0432\u044C\u0442\u0435 --yes, \u0447\u0442\u043E\u0431\u044B \u043F\u0440\u0438\u043C\u0435\u043D\u0438\u0442\u044C.", "Nothing was removed: add --yes to apply."));
+    return;
+  }
+  for (const change of changes) {
+    await change.remove();
+    writers.out(`\u2714 ${change.action}: ${change.path}`);
+  }
+  writers.out(tr("revdeck \u0443\u0434\u0430\u043B\u0451\u043D \u0438\u0437 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044F.", "revdeck was removed from the repository."));
+}
+async function isManagedSkill(target) {
+  try {
+    const info = await lstat3(target);
+    if (info.isSymbolicLink()) return true;
+    if (!info.isDirectory()) return false;
+    const skill = path7.join(target, "SKILL.md");
+    if (!existsSync7(skill)) return false;
+    const text = await readFile5(skill, "utf8");
+    return /^name:\s*revdeck\s*$/m.test(text) || /revdeck/i.test(text.slice(0, 2e3));
+  } catch {
+    return false;
+  }
+}
+
 // src/cli/export.ts
 init_client();
 init_format();
 init_locale();
-import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
-import path6 from "node:path";
+import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
+import path8 from "node:path";
 async function reviewFor(client2, root, arg) {
   if (arg && /^(gitlab|github):/.test(arg)) {
     const { review } = await client2.request("reviews.get", { review: arg });
@@ -1863,13 +2349,13 @@ async function exportReview(root, arg, dir) {
   const { client: client2 } = await ensureDaemon();
   try {
     const review = await reviewFor(client2, root, arg);
-    const target = path6.resolve(root, dir);
-    await mkdir3(target, { recursive: true });
+    const target = path8.resolve(root, dir);
+    await mkdir4(target, { recursive: true });
     const base = `mr-${review.info.ref.number}`;
     const files = [];
     const write = async (name, data) => {
-      const file = path6.join(target, name);
-      await writeFile2(file, `${JSON.stringify(data, null, 2)}
+      const file = path8.join(target, name);
+      await writeFile4(file, `${JSON.stringify(data, null, 2)}
 `, { mode: 420 });
       files.push(name);
     };
@@ -1934,9 +2420,9 @@ async function exportReview(root, arg, dir) {
       }
     }
     await write(`${base}-published.json`, published);
-    await writeFile2(path6.join(target, `${base}.diff`), await serializeDiff(client2, review), { mode: 420 });
+    await writeFile4(path8.join(target, `${base}.diff`), await serializeDiff(client2, review), { mode: 420 });
     files.push(`${base}.diff`);
-    writers.out(`${tr("\u044D\u043A\u0441\u043F\u043E\u0440\u0442\u0438\u0440\u043E\u0432\u0430\u043D\u043E \u0432", "exported to")} ${path6.relative(root, target)}: ${files.join(", ")}`);
+    writers.out(`${tr("\u044D\u043A\u0441\u043F\u043E\u0440\u0442\u0438\u0440\u043E\u0432\u0430\u043D\u043E \u0432", "exported to")} ${path8.relative(root, target)}: ${files.join(", ")}`);
   } finally {
     client2.close();
   }
@@ -1945,11 +2431,11 @@ async function importReview(root, arg, dir) {
   const { client: client2 } = await ensureDaemon();
   try {
     const review = await reviewFor(client2, root, arg);
-    const target = path6.resolve(root, dir);
+    const target = path8.resolve(root, dir);
     const base = `mr-${review.info.ref.number}`;
     const read = async (name) => {
       try {
-        return JSON.parse(await readFile4(path6.join(target, name), "utf8"));
+        return JSON.parse(await readFile6(path8.join(target, name), "utf8"));
       } catch {
         return null;
       }
@@ -1997,6 +2483,53 @@ async function importReview(root, arg, dir) {
   }
 }
 
+// src/core/attachments.ts
+var MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
+var MIME_BY_EXTENSION = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".mp4": "video/mp4",
+  ".m4v": "video/mp4",
+  ".webm": "video/webm",
+  ".ogv": "video/ogg",
+  ".ogg": "video/ogg",
+  ".mov": "video/quicktime"
+};
+function extensionOf(name) {
+  const index = name.lastIndexOf(".");
+  return index >= 0 ? name.slice(index).toLowerCase() : "";
+}
+function attachmentSpec(name, contentType = "") {
+  if (/[/\\]/.test(name)) return null;
+  const base = name.replace(/[\u0000-\u001f\u007f]/g, "").trim();
+  if (!base || base.length > 240) return null;
+  const extension = extensionOf(base);
+  const expected = MIME_BY_EXTENSION[extension];
+  if (!expected) return null;
+  const provided = normalizeContentType(String(contentType));
+  if (provided && provided !== expected) return null;
+  return {
+    name: base,
+    contentType: expected,
+    extension,
+    kind: expected.startsWith("image/") ? "image" : "video"
+  };
+}
+var CONTENT_TYPE_ALIASES = {
+  "image/jpg": "image/jpeg",
+  "image/pjpeg": "image/jpeg",
+  "video/x-m4v": "video/mp4",
+  "video/x-ogg": "video/ogg"
+};
+function normalizeContentType(value) {
+  const type = value.split(";")[0].trim().toLowerCase();
+  return CONTENT_TYPE_ALIASES[type] ?? type;
+}
+
 // src/cli/main.ts
 init_context();
 var OPTIONS = {
@@ -2027,10 +2560,13 @@ var OPTIONS = {
   force: { type: "boolean", default: false },
   adapters: { type: "string" },
   "no-service": { type: "boolean", default: false },
+  "keep-config": { type: "boolean", default: false },
+  write: { type: "boolean", default: false },
   explain: { type: "string" },
   limit: { type: "string" },
   decision: { type: "string" },
   note: { type: "string" },
+  emoji: { type: "string" },
   text: { type: "string" },
   line: { type: "string" },
   id: { type: "string" },
@@ -2049,6 +2585,8 @@ function parse(argv) {
 var HELP_RU = `revdeck ${VERSION} \u2014 \u0440\u0435\u0432\u044C\u044E GitLab/GitHub \u0434\u043B\u044F \u043B\u044E\u0434\u0435\u0439 \u0438 \u0430\u0433\u0435\u043D\u0442\u043E\u0432
 
   revdeck init            \u043D\u0430\u0441\u0442\u0440\u043E\u0438\u0442\u044C \u043F\u0440\u043E\u0435\u043A\u0442: .revdeck.yml, \u0430\u0434\u0430\u043F\u0442\u0435\u0440\u044B, MCP
+  revdeck eject           \u0443\u0434\u0430\u043B\u0438\u0442\u044C revdeck \u0438\u0437 \u043F\u0440\u043E\u0435\u043A\u0442\u0430 (--yes; --keep-config)
+  revdeck devcontainer    \u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0438\u0442\u044C devcontainer \u043A \u0434\u0435\u043C\u043E\u043D\u0443 \u0445\u043E\u0441\u0442\u0430 (--write)
   revdeck doctor          \u043F\u0440\u043E\u0432\u0435\u0440\u0438\u0442\u044C \u043E\u043A\u0440\u0443\u0436\u0435\u043D\u0438\u0435 \u0438 \u0434\u043E\u0441\u0442\u0443\u043F\u044B
   revdeck daemon <start|stop|status|logs|restart>
   revdeck list            \u043E\u0442\u043A\u0440\u044B\u0442\u044B\u0435 \u0440\u0435\u0432\u044C\u044E (\u043B\u043E\u043A\u0430\u043B\u044C\u043D\u044B\u0439 \u043A\u0435\u0448), --remote \u2014 \u0441 \u043F\u043B\u0430\u0442\u0444\u043E\u0440\u043C\u044B
@@ -2061,6 +2599,8 @@ var HELP_RU = `revdeck ${VERSION} \u2014 \u0440\u0435\u0432\u044C\u044E GitLab/G
   revdeck summary <N> [--file <json>]      \u0432\u044B\u0436\u0438\u043C\u043A\u0430 MR
   revdeck reply <N> --thread <id> (--body <\u0442\u0435\u043A\u0441\u0442> | --body-file <\u0444\u0430\u0439\u043B> | -) [--resolve] [--publish --yes]
   revdeck notes <N> <list|add|update|delete|reply>
+  revdeck react <N> --note <id> --emoji <name>   \u043F\u043E\u0441\u0442\u0430\u0432\u0438\u0442\u044C \u0438\u043B\u0438 \u0441\u043D\u044F\u0442\u044C \u0440\u0435\u0430\u043A\u0446\u0438\u044E
+  revdeck attach <N> --file <\u043F\u0443\u0442\u044C>               \u0437\u0430\u0433\u0440\u0443\u0437\u0438\u0442\u044C \u043A\u0430\u0440\u0442\u0438\u043D\u043A\u0443/\u0432\u0438\u0434\u0435\u043E \u0432 \u043F\u043B\u0430\u0442\u0444\u043E\u0440\u043C\u0443
   revdeck publish <N> [--kind reply|finding|note] [--ids a,b] [--yes]
   revdeck rules [<N>] [--explain <\u043F\u0443\u0442\u044C>]
   revdeck checks <N> [--run --yes]
@@ -2074,6 +2614,8 @@ var HELP_RU = `revdeck ${VERSION} \u2014 \u0440\u0435\u0432\u044C\u044E GitLab/G
 var HELP_EN = `revdeck ${VERSION} \u2014 code review for GitLab/GitHub, for humans and agents
 
   revdeck init            set up a project: .revdeck.yml, adapters, MCP
+  revdeck eject           remove revdeck from the project (--yes; --keep-config)
+  revdeck devcontainer    connect a devcontainer to the host daemon (--write)
   revdeck doctor          check the environment and access
   revdeck daemon <start|stop|status|logs|restart>
   revdeck list            open reviews (local cache), --remote \u2014 from the platform
@@ -2086,6 +2628,8 @@ var HELP_EN = `revdeck ${VERSION} \u2014 code review for GitLab/GitHub, for huma
   revdeck summary <N> [--file <json>]      review summary
   revdeck reply <N> --thread <id> (--body <text> | --body-file <file> | -) [--resolve] [--publish --yes]
   revdeck notes <N> <list|add|update|delete|reply>
+  revdeck react <N> --note <id> --emoji <name>   add or remove a reaction
+  revdeck attach <N> --file <path>               upload an image/video to the platform
   revdeck publish <N> [--kind reply|finding|note] [--ids a,b] [--yes]
   revdeck rules [<N>] [--explain <path>]
   revdeck checks <N> [--run --yes]
@@ -2120,10 +2664,14 @@ async function main2() {
   switch (command) {
     case "init":
       return runInit(root, { force: values.force === true, adapters: parseList(values.adapters), noService: values["no-service"] === true, locale: values.lang === "ru" || values.lang === "en" ? values.lang : detectLocale(), outputLanguage: values.lang === "ru" || values.lang === "en" ? values.lang : "auto" });
+    case "eject":
+      return runEject(root, { yes: values.yes === true && values["dry-run"] !== true, keepConfig: values["keep-config"] === true });
+    case "devcontainer":
+      return runDevcontainer(root, { write: values.write === true });
     case "doctor":
       return doctor(root);
     case "daemon":
-      return daemon(positionals[0] ?? "status");
+      return daemon(positionals[0] ?? "status", values);
     case "list":
       return list(root, values);
     case "open":
@@ -2147,6 +2695,10 @@ async function main2() {
       return reply(positionals[0], values);
     case "notes":
       return notes(positionals[0], positionals[1] ?? "list", values);
+    case "react":
+      return react(positionals[0], values);
+    case "attach":
+      return attach(positionals[0], values);
     case "publish":
       return publish(positionals[0], values);
     case "rules":
@@ -2259,13 +2811,14 @@ async function ui(arg, values) {
   });
   const info = await daemonInfo();
   if (!info) fail(tr("\u0434\u0435\u043C\u043E\u043D \u043D\u0435 \u0437\u0430\u043F\u0443\u0449\u0435\u043D", "the daemon is not running"), "revdeck daemon start");
-  writers.out(`${info.url}/?t=${info.token}`);
-  if (values.open) openBrowser(`${info.url}/?t=${info.token}`);
+  const url = `${uiBaseUrl(info)}/?t=${info.token}`;
+  writers.out(url);
+  if (values.open) openBrowser(url);
 }
 function printUi(reviewId, values) {
   const info = daemonInfoSync();
   if (!info) return writers.err(tr("\u0434\u0435\u043C\u043E\u043D \u043D\u0435 \u0437\u0430\u043F\u0443\u0449\u0435\u043D: revdeck daemon start", "the daemon is not running: revdeck daemon start"));
-  const url = `${info.url}/?t=${info.token}${reviewId ? `&review=${encodeURIComponent(reviewId)}` : ""}`;
+  const url = `${uiBaseUrl(info)}/?t=${info.token}${reviewId ? `&review=${encodeURIComponent(reviewId)}` : ""}`;
   writers.out(`UI: ${url}`);
   if (values.open) openBrowser(url);
 }
@@ -2283,14 +2836,25 @@ function openBrowser(url) {
     spawn2(command, args, { detached: true, stdio: "ignore" }).unref();
   });
 }
-async function daemon(action) {
+async function daemon(action, values = {}) {
+  if (isDevContainer() && ["start", "stop", "restart", "install", "uninstall"].includes(action)) {
+    fail(
+      tr(
+        "\u0432 devcontainer \u0434\u0435\u043C\u043E\u043D\u043E\u043C \u0443\u043F\u0440\u0430\u0432\u043B\u044F\u0435\u0442 \u0445\u043E\u0441\u0442: \u0432\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u0435 \u043A\u043E\u043C\u0430\u043D\u0434\u0443 \u043D\u0430 \u0445\u043E\u0441\u0442\u0435",
+        "the daemon is managed by the host in a devcontainer: run this command on the host"
+      ),
+      tr("revdeck daemon restart \u043D\u0430 \u0445\u043E\u0441\u0442\u0435", "revdeck daemon restart on the host")
+    );
+  }
   if (action === "start") {
-    const { client: client2, started } = await ensureDaemon();
+    const { client: client2, started } = await ensureDaemon({
+      ...values.host ? { daemonArgs: ["--host", String(values.host)] } : {}
+    });
     const ping = await client2.request("ping");
     client2.close();
     const info = await daemonInfo();
     writers.out(`${started ? tr("\u0437\u0430\u043F\u0443\u0449\u0435\u043D", "started") : tr("\u0443\u0436\u0435 \u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442", "already running")} ${tr("\u0434\u0435\u043C\u043E\u043D", "daemon")} pid ${ping.pid}, ${tr("\u0432\u0435\u0440\u0441\u0438\u044F", "version")} ${ping.version}`);
-    if (info) writers.out(`${info.url}/?t=${info.token}`);
+    if (info) writers.out(`${uiBaseUrl(info)}/?t=${info.token}`);
     return;
   }
   if (action === "status") {
@@ -2330,11 +2894,11 @@ async function daemon(action) {
   }
   if (action === "restart") {
     await daemon("stop");
-    return daemon("start");
+    return daemon("start", values);
   }
   if (action === "logs") {
     try {
-      const text = await readFile5(logPath(), "utf8");
+      const text = await readFile7(logPath(), "utf8");
       writers.out(text.split("\n").slice(-80).join("\n"));
     } catch {
       writers.out(tr("\u043B\u043E\u0433 \u043F\u0443\u0441\u0442", "the log is empty"));
@@ -2399,7 +2963,7 @@ async function findings(arg, action, values) {
     const { review } = await resolveReview(client2, findRepoRoot(), reviewArg(values, arg), values);
     if (action === "set") {
       if (!values.file) fail(tr("\u0443\u043A\u0430\u0436\u0438\u0442\u0435 --file \u0441 JSON \u0437\u0430\u043C\u0435\u0447\u0430\u043D\u0438\u0439", "pass --file with findings JSON"));
-      const raw = JSON.parse(await readFile5(String(values.file), "utf8"));
+      const raw = JSON.parse(await readFile7(String(values.file), "utf8"));
       const list2 = Array.isArray(raw) ? raw : raw.findings;
       if (!Array.isArray(list2)) fail(tr("\u043E\u0436\u0438\u0434\u0430\u043B\u0441\u044F \u043C\u0430\u0441\u0441\u0438\u0432 \u0438\u043B\u0438 {findings: [...]}", "expected an array or {findings: [...]}"));
       const { findings: saved } = await client2.request("findings.put", { review: review.id, findings: list2 });
@@ -2426,7 +2990,7 @@ async function findings(arg, action, values) {
 }
 async function summary(arg, values) {
   if (!values.file && process.stdin.isTTY) fail(tr("\u0443\u043A\u0430\u0436\u0438\u0442\u0435 --file \u0441 JSON \u0432\u044B\u0436\u0438\u043C\u043A\u0438 \u0438\u043B\u0438 \u043F\u0435\u0440\u0435\u0434\u0430\u0439\u0442\u0435 \u0435\u0451 \u0447\u0435\u0440\u0435\u0437 stdin", "pass --file with summary JSON or pipe it via stdin"));
-  const raw = values.file ? JSON.parse(await readFile5(String(values.file), "utf8")) : JSON.parse(await readStdin());
+  const raw = values.file ? JSON.parse(await readFile7(String(values.file), "utf8")) : JSON.parse(await readStdin());
   await withClient(async ({ client: client2 }) => {
     const { review } = await resolveReview(client2, findRepoRoot(), reviewArg(values, arg), values);
     const result = await client2.request("summary.put", { review: review.id, summary: raw });
@@ -2498,6 +3062,45 @@ async function notes(arg, action, values) {
     }
   });
 }
+async function react(arg, values) {
+  if (!values.note || !values.emoji) fail(tr("\u043D\u0443\u0436\u043D\u044B --note <id> \u0438 --emoji <name>", "--note <id> and --emoji <name> are required"));
+  await withClient(async ({ client: client2 }) => {
+    const { review } = await resolveReview(client2, findRepoRoot(), reviewArg(values, arg), values);
+    const result = await client2.request("reactions.toggle", {
+      review: review.id,
+      noteId: String(values.note),
+      emoji: String(values.emoji)
+    });
+    if (values.json) return printJson(result);
+    writers.out(`${result.active ? "\u2714" : "\u25CB"} ${values.emoji}${result.active ? ` \xB7 ${tr("\u043F\u043E\u0441\u0442\u0430\u0432\u043B\u0435\u043D\u0430", "added")}` : ` \xB7 ${tr("\u0441\u043D\u044F\u0442\u0430", "removed")}`}`);
+    for (const reaction of result.reactions) writers.out(`  ${reaction.name}${reaction.mine ? " \xB7" : ""} ${reaction.count}`);
+  });
+}
+async function attach(arg, values) {
+  if (!values.file) fail(tr("\u0443\u043A\u0430\u0436\u0438\u0442\u0435 --file \u0441 \u043A\u0430\u0440\u0442\u0438\u043D\u043A\u043E\u0439 \u0438\u043B\u0438 \u0432\u0438\u0434\u0435\u043E", "pass --file with an image or video"));
+  const name = path9.basename(String(values.file));
+  const spec = attachmentSpec(name);
+  if (!spec) fail(tr("\u0440\u0430\u0437\u0440\u0435\u0448\u0435\u043D\u044B PNG, JPEG, GIF, WebP, AVIF, MP4, WebM, OGV \u0438 MOV", "PNG, JPEG, GIF, WebP, AVIF, MP4, WebM, OGV and MOV are allowed"));
+  const file = String(values.file);
+  const info = await stat(file).catch(() => null);
+  if (!info?.isFile()) fail(tr(`\u043D\u0435\u0442 \u0444\u0430\u0439\u043B\u0430 ${file}`, `file ${file} does not exist`));
+  if (info.size > MAX_ATTACHMENT_BYTES) {
+    fail(tr(`\u0444\u0430\u0439\u043B \u0431\u043E\u043B\u044C\u0448\u0435 ${Math.floor(MAX_ATTACHMENT_BYTES / (1024 * 1024))} \u041C\u0411`, `file is larger than ${Math.floor(MAX_ATTACHMENT_BYTES / (1024 * 1024))} MB`));
+  }
+  const data = await readFile7(file);
+  await withClient(async ({ client: client2 }) => {
+    const { review } = await resolveReview(client2, findRepoRoot(), reviewArg(values, arg), values);
+    const result = await client2.request("attachments.upload", {
+      review: review.id,
+      name,
+      contentType: spec.contentType,
+      data: data.toString("base64")
+    });
+    if (values.json) return printJson(result.attachment);
+    writers.out(`${tr("\u0437\u0430\u0433\u0440\u0443\u0436\u0435\u043D\u043E", "uploaded")}: ${result.attachment.url}`);
+    writers.out(result.attachment.markdown);
+  });
+}
 async function publish(arg, values) {
   await withClient(async ({ client: client2 }) => {
     const { review } = await resolveReview(client2, findRepoRoot(), reviewArg(values, arg), values);
@@ -2606,7 +3209,7 @@ async function readBodyInput(values) {
   if (values["body-file"] !== void 0) {
     const file = String(values["body-file"]);
     if (file === "-") return readStdin();
-    return readFile5(file, "utf8");
+    return readFile7(file, "utf8");
   }
   if (process.stdin.isTTY) return null;
   return readStdin();
@@ -2618,12 +3221,20 @@ async function readStdin() {
 }
 async function doctor(root) {
   const rows = [];
+  const container = isDevContainer();
   const major = Number(process.version.slice(1).split(".")[0]);
   rows.push(["node", major >= 22 ? "ok" : "fail", process.version]);
+  if (container) {
+    rows.push(["mode", "ok", tr("devcontainer: revdeck \u0438 gh/glab \u0440\u0430\u0431\u043E\u0442\u0430\u044E\u0442 \u043D\u0430 \u0445\u043E\u0441\u0442\u0435", "devcontainer: revdeck and gh/glab run on the host")]);
+  }
   const binaries = {};
   for (const bin of ["glab", "gh", "git"]) {
     const present = await which(bin);
     binaries[bin] = present;
+    if (container && (bin === "glab" || bin === "gh")) {
+      rows.push([bin, "ok", present ? tr("\u0435\u0441\u0442\u044C \u0432 \u043A\u043E\u043D\u0442\u0435\u0439\u043D\u0435\u0440\u0435, \u043D\u043E \u043D\u0435 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0435\u0442\u0441\u044F", "present in the container but unused") : tr("\u043D\u0435 \u043D\u0443\u0436\u0435\u043D \u0432 \u043A\u043E\u043D\u0442\u0435\u0439\u043D\u0435\u0440\u0435: \u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442 \u043D\u0430 \u0445\u043E\u0441\u0442\u0435", "not needed in the container: the host runs it")]);
+      continue;
+    }
     rows.push([bin, present ? "ok" : "warn", present ? tr("\u043D\u0430\u0439\u0434\u0435\u043D", "found") : tr("\u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D", "not found")]);
   }
   let host;
@@ -2635,28 +3246,35 @@ async function doctor(root) {
   } catch (error) {
     rows.push(["config", "fail", redactLine(error)]);
   }
-  if (host && binaries.glab) {
-    try {
-      await run("glab", ["auth", "status", "--hostname", host], { timeoutMs: 15e3 });
-      rows.push(["glab auth", "ok", host]);
-    } catch (error) {
-      rows.push(["glab auth", "warn", `${tr("\u043D\u0435\u0442 \u0434\u043E\u0441\u0442\u0443\u043F\u0430 \u043A", "no access to")} ${host}: ${redactLine(error).slice(0, 120)}`]);
+  if (!container) {
+    if (host && binaries.glab) {
+      try {
+        await run("glab", ["auth", "status", "--hostname", host], { timeoutMs: 15e3 });
+        rows.push(["glab auth", "ok", host]);
+      } catch (error) {
+        rows.push(["glab auth", "warn", `${tr("\u043D\u0435\u0442 \u0434\u043E\u0441\u0442\u0443\u043F\u0430 \u043A", "no access to")} ${host}: ${redactLine(error).slice(0, 120)}`]);
+      }
     }
-  }
-  if (host && binaries.gh) {
-    try {
-      await run("gh", ["auth", "status"], { timeoutMs: 15e3, env: { GH_HOST: host } });
-      rows.push(["gh auth", "ok", host]);
-    } catch (error) {
-      rows.push(["gh auth", "warn", `${tr("\u043D\u0435\u0442 \u0434\u043E\u0441\u0442\u0443\u043F\u0430 \u043A", "no access to")} ${host}: ${redactLine(error).slice(0, 120)}`]);
+    if (host && binaries.gh) {
+      try {
+        await run("gh", ["auth", "status"], { timeoutMs: 15e3, env: { GH_HOST: host } });
+        rows.push(["gh auth", "ok", host]);
+      } catch (error) {
+        rows.push(["gh auth", "warn", `${tr("\u043D\u0435\u0442 \u0434\u043E\u0441\u0442\u0443\u043F\u0430 \u043A", "no access to")} ${host}: ${redactLine(error).slice(0, 120)}`]);
+      }
     }
   }
   const running = await isDaemonRunning();
   const info = await daemonInfo();
-  rows.push(["daemon", running ? "ok" : "warn", running && info ? `${info.url} (pid ${info.pid})` : tr("\u043D\u0435 \u0437\u0430\u043F\u0443\u0449\u0435\u043D (\u0437\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u0441\u044F \u0441\u0430\u043C)", "not running (starts on demand)")]);
-  rows.push(["ui", "ok", info?.url ?? tr("\u0431\u0443\u0434\u0435\u0442 \u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D \u043F\u043E\u0441\u043B\u0435 \u0437\u0430\u043F\u0443\u0441\u043A\u0430", "available after the daemon starts")]);
-  const { existsSync: existsSync6 } = await import("node:fs");
-  const skill = existsSync6(path7.join(root, ".agents", "skills", "revdeck", "SKILL.md")) || existsSync6(path7.join(root, ".claude", "skills", "revdeck", "SKILL.md")) || existsSync6(path7.join(root, ".cursor", "commands", "revdeck.md"));
+  const daemonStatus = running ? "ok" : container ? "fail" : "warn";
+  rows.push([
+    "daemon",
+    daemonStatus,
+    running && info ? `${uiBaseUrl(info)} (pid ${info.pid})` : container ? tr("\u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: \u043D\u0430 \u0445\u043E\u0441\u0442\u0435 \u0432\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u0435 revdeck daemon start", "not found: run revdeck daemon start on the host") : tr("\u043D\u0435 \u0437\u0430\u043F\u0443\u0449\u0435\u043D (\u0437\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u0441\u044F \u0441\u0430\u043C)", "not running (starts on demand)")
+  ]);
+  rows.push(["ui", running ? "ok" : "warn", info ? uiBaseUrl(info) : tr("\u0431\u0443\u0434\u0435\u0442 \u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D \u043F\u043E\u0441\u043B\u0435 \u0437\u0430\u043F\u0443\u0441\u043A\u0430", "available after the daemon starts")]);
+  const { existsSync: existsSync8 } = await import("node:fs");
+  const skill = existsSync8(path9.join(root, ".agents", "skills", "revdeck", "SKILL.md")) || existsSync8(path9.join(root, ".claude", "skills", "revdeck", "SKILL.md")) || existsSync8(path9.join(root, ".cursor", "commands", "revdeck.md"));
   rows.push(["adapter", skill ? "ok" : "warn", skill ? tr("\u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D", "installed") : tr("\u043D\u0435\u0442: revdeck init", "missing: revdeck init")]);
   for (const [name, status2, detail] of rows) {
     writers.out(`${status2 === "ok" ? "\u2714" : status2 === "warn" ? "!" : "\u2716"} ${name.padEnd(10)} ${detail}`);