@i14ks/ccv 0.6.2 → 0.7.1

package/bundle/ccv.mjs

@@ -2,8 +2,8 @@
 
 // dist/ccv.js
 import { spawn as spawn2 } from "node:child_process";
-import { readFile as readFile11 } from "node:fs/promises";
-import path16 from "node:path";
+import { readFile as readFile13 } from "node:fs/promises";
+import path18 from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 
@@ -146,7 +146,7 @@ function envDefaults() {
 // ../host/dist/server.js
 import { createServer } from "node:http";
 import { createReadStream, existsSync as existsSync3, statSync as statSync3 } from "node:fs";
-import path15 from "node:path";
+import path17 from "node:path";
 import { homedir as homedir5 } from "node:os";
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { WebSocketServer } from "ws";
@@ -2246,7 +2246,11 @@ function contentToText2(content) {
 
 // ../host/dist/git.js
 import { execFile as execFile2 } from "node:child_process";
+import { mkdtemp, readFile as readFile4, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path6 from "node:path";
 var TIMEOUT_MS = 2e4;
+var NET_TIMEOUT_MS = 5 * 6e4;
 var MAX_BUFFER = 32 * 1024 * 1024;
 var LOG_LIMIT = 150;
 var UNPUSHED_LIMIT = 2e3;
@@ -2255,6 +2259,8 @@ var MAX_FILE_PATCH = 8e4;
 var UNIT = "";
 var RECORD = "";
 var SAFE_REF = /^[A-Za-z0-9][A-Za-z0-9._/@^~-]*$/;
+var SAFE_URL = /^(?:https?:\/\/|ssh:\/\/|git:\/\/|[A-Za-z0-9._-]+@[A-Za-z0-9._-]+:)[^\s]+$/;
+var CANDIDATE_LIMIT = 2e3;
 var GitRepo = class {
   cwd;
   constructor(cwd) {
@@ -2271,11 +2277,13 @@ var GitRepo = class {
     const blank = {
       available: false,
       message: "",
+      noRepo: false,
       branch: "",
       head: "",
       detached: false,
       upstream: "",
       hasRemote: false,
+      remoteUrl: "",
       ahead: 0,
       behind: 0,
       changed: [],
@@ -2285,7 +2293,8 @@ var GitRepo = class {
     try {
       await this.#run(["rev-parse", "--is-inside-work-tree"]);
     } catch (error) {
-      return { ...blank, message: describe2(error) };
+      const runnable2 = await this.#run(["--version"]).then(() => true, () => false);
+      return { ...blank, message: describe2(error), noRepo: runnable2 };
     }
     const branchRaw = await this.#soft(["rev-parse", "--abbrev-ref", "HEAD"]);
     const detached = branchRaw === "HEAD" || branchRaw === "";
@@ -2301,11 +2310,14 @@ var GitRepo = class {
     return {
       available: true,
       message: "",
+      // Репозиторий есть — заводить нечего.
+      noRepo: false,
       branch: detached ? "" : branchRaw,
       head: await this.#soft(["rev-parse", "HEAD"]),
       detached,
       upstream,
       hasRemote,
+      remoteUrl: await this.#soft(["remote", "get-url", "origin"]),
       ahead: Number(ahead) || 0,
       behind: Number(behind) || 0,
       changed: parseStatus(await this.#soft(["status", "--porcelain=v1"])),
@@ -2432,12 +2444,11 @@ var GitRepo = class {
   async checkIgnored(paths) {
     if (paths.length === 0)
       return /* @__PURE__ */ new Set();
-    const raw = await this.#run(
-      ["check-ignore", "--stdin", "-z"],
+    const raw = await this.#run(["check-ignore", "--stdin", "-z"], {
       // `-z` переводит на NUL и вход тоже — иначе путь с переводом строки в
       // имени разъехался бы на две записи.
-      paths.join("\0")
-    ).catch(() => "");
+      input: paths.join("\0")
+    }).catch(() => "");
     return new Set(raw.split("\0").filter(Boolean));
   }
   /**
@@ -2455,24 +2466,195 @@ var GitRepo = class {
     const out = await this.#run(["checkout", requireRef(target), "--"]);
     return out || `\u041F\u0435\u0440\u0435\u043A\u043B\u044E\u0447\u0435\u043D\u043E \u043D\u0430 ${target}`;
   }
+  /**
+   * Отправить текущую ветку.
+   *
+   * Ветка берётся здесь, а не приходит параметром: отправить можно только то,
+   * на чём стоит HEAD, и принимать её снаружи значило бы дать окну отправить
+   * не ту ветку, которую человек видит перед собой.
+   *
+   * Первый push ветки добавляет `--set-upstream`: без него git отправит
+   * коммиты, но связь с удалённой веткой не заведёт, и панель после успешной
+   * отправки продолжит показывать «не отправлено». Дальше аргументов нет
+   * вовсе — `git push` сам знает, куда, и уважает `push.default` из настроек
+   * пользователя.
+   */
+  async push(token) {
+    const branch = await this.#soft(["rev-parse", "--abbrev-ref", "HEAD"]);
+    if (branch === "" || branch === "HEAD") {
+      throw new Error("HEAD \u043E\u0442\u0434\u0435\u043B\u0451\u043D \u043E\u0442 \u0432\u0435\u0442\u043A\u0438 \u2014 \u0441\u043D\u0430\u0447\u0430\u043B\u0430 \u043F\u0435\u0440\u0435\u043A\u043B\u044E\u0447\u0438\u0442\u0435\u0441\u044C \u043D\u0430 \u0432\u0435\u0442\u043A\u0443");
+    }
+    const upstream = await this.#soft([
+      "rev-parse",
+      "--abbrev-ref",
+      "--symbolic-full-name",
+      "@{upstream}"
+    ]);
+    const out = await this.#run(upstream ? ["push"] : ["push", "--set-upstream", "origin", branch], { token, timeout: NET_TIMEOUT_MS });
+    return out || `\u041E\u0442\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u043E: ${branch}`;
+  }
+  /**
+   * Забрать с удалённого репозитория.
+   *
+   * `merge: false` — только `fetch`: счётчики «отстаём/опережаем» обновятся, а
+   * рабочее дерево останется каким было. Это безопасное действие, и оно же
+   * единственный способ узнать, что на remote что-то появилось.
+   *
+   * `merge: true` — `pull --ff-only`. Только перемотка: настоящее слияние
+   * создаёт коммит и умеет оставить дерево в конфликте, а разбирать конфликт
+   * из панели истории нечем. Когда перемотка невозможна, git отказывается сам,
+   * и его текст объясняет это лучше нашего.
+   */
+  async pull(merge, token) {
+    if (!merge) {
+      const out2 = await this.#run(["fetch", "--all", "--prune"], {
+        token,
+        timeout: NET_TIMEOUT_MS
+      });
+      return out2 || "\u0418\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u044F \u0437\u0430\u0431\u0440\u0430\u043D\u044B \u2014 \u0438\u0441\u0442\u043E\u0440\u0438\u044F remote \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0430";
+    }
+    const out = await this.#run(["pull", "--ff-only"], { token, timeout: NET_TIMEOUT_MS });
+    return out || "\u041E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u043E";
+  }
+  /**
+   * Прописать `origin`.
+   *
+   * `set-url`, если он уже есть: «добавить существующее» — обычная причина
+   * сюда попасть (адрес поменялся, репозиторий переехал), и отвечать на неё
+   * ошибкой git «remote origin already exists» значило бы требовать удалить
+   * remote где-то ещё, а такого места в приложении нет.
+   */
+  async setRemote(url2) {
+    const target = requireUrl(url2);
+    const existing = await this.#soft(["remote", "get-url", "origin"]);
+    await this.#run(existing ? ["remote", "set-url", "origin", target] : ["remote", "add", "origin", target]);
+    return existing ? `origin \u0442\u0435\u043F\u0435\u0440\u044C ${target}` : `origin \u2014 ${target}`;
+  }
+  /**
+   * Что можно положить в первый коммит.
+   *
+   * `--others --cached` — файлы, которых нет в истории: неотслеживаемые и уже
+   * добавленные в индекс. `--exclude-standard` уважает существующий
+   * `.gitignore`: если человек уже описал, что в репозиторий не нужно,
+   * спрашивать его об этом второй раз галочками незачем.
+   *
+   * `-z` — потому что путь с переводом строки в имени иначе разъехался бы на
+   * две записи, и в коммит попал бы файл с выдуманным именем.
+   */
+  async candidates() {
+    const args = ["ls-files", "-z", "--others", "--cached", "--exclude-standard"];
+    const inside = await this.#run(["rev-parse", "--is-inside-work-tree"]).then(() => true, () => false);
+    const raw = inside ? await this.#soft(args) : await this.#withoutRepo(args);
+    const all = raw.split("\0").filter(Boolean);
+    return { files: all.slice(0, CANDIDATE_LIMIT), truncated: all.length > CANDIDATE_LIMIT };
+  }
+  /**
+   * Спросить git о каталоге, который репозиторием ещё не стал.
+   *
+   * Нужно ровно для одного: показать список файлов до публикации проекта, у
+   * которого нет даже `.git`. Просто позвать `git init` заранее нельзя —
+   * открытие окна не должно оставлять после себя репозиторий, если человек
+   * передумал и закрыл его.
+   *
+   * Поэтому репозиторий заводится пустой и во временном каталоге, а рабочим
+   * деревом ему назначается проект: `--exclude-standard` при этом читает
+   * настоящий `.gitignore` проекта, и список получается тот же, что и после
+   * `git init`. Свой обход каталога дал бы другой — правила игнорирования
+   * пришлось бы разбирать самим, и они разошлись бы с git ровно там, где это
+   * важнее всего (см. `checkIgnored`).
+   */
+  async #withoutRepo(args) {
+    const dir = await mkdtemp(path6.join(tmpdir(), "ccv-git-"));
+    try {
+      await this.#run(["init", "--bare", "--quiet", dir]);
+      return await this.#soft([`--git-dir=${dir}`, `--work-tree=${this.cwd}`, ...args]);
+    } finally {
+      await rm2(dir, { recursive: true, force: true }).catch(() => void 0);
+    }
+  }
+  /**
+   * Первый коммит: дописать `.gitignore`, добавить выбранное, закоммитить.
+   *
+   * Ровно тот порядок, что и в «Publish to GitHub» у VS Code, и он важен:
+   * `.gitignore` должен попасть в тот же коммит, что и файлы, иначе первый же
+   * `git status` после публикации покажет его неотслеживаемым.
+   *
+   * Пути уходят через stdin (`--pathspec-from-file=-`), а не аргументами: их
+   * тут могут быть тысячи, и в командную строку Windows они не влезут. `--nul`
+   * к тому же снимает вопрос о путях с пробелами и переводами строк, а заодно
+   * лишает строку магии pathspec — `:(exclude)` из браузера здесь не сработает.
+   */
+  async commit(message, include, ignore) {
+    const text = message.trim();
+    if (!text)
+      throw new Error("\u041F\u0443\u0441\u0442\u043E\u0435 \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435 \u043A\u043E\u043C\u043C\u0438\u0442\u0430");
+    const paths = include.map(requirePath);
+    if (paths.length === 0)
+      throw new Error("\u041D\u0435 \u0432\u044B\u0431\u0440\u0430\u043D\u043E \u043D\u0438 \u043E\u0434\u043D\u043E\u0433\u043E \u0444\u0430\u0439\u043B\u0430 \u0434\u043B\u044F \u043F\u0435\u0440\u0432\u043E\u0433\u043E \u043A\u043E\u043C\u043C\u0438\u0442\u0430");
+    const ignored = ignore.map(requirePath);
+    if (ignored.length > 0) {
+      await this.#appendGitignore(ignored);
+      paths.push(".gitignore");
+    }
+    await this.#run(["add", "--pathspec-from-file=-", "--pathspec-file-nul"], {
+      input: paths.join("\0")
+    });
+    return await this.#run(["commit", "-m", text]);
+  }
+  /**
+   * Дописать в `.gitignore` то, что не выбрали.
+   *
+   * Дописать, а не переписать: файл мог быть уже — с правилами, которые сюда
+   * не приходили (их пути `--exclude-standard` из списка и убрал), и затереть
+   * их значило бы вернуть в репозиторий ровно то, что человек однажды из него
+   * исключил. Повторы отсеиваются, чтобы файл не рос от каждой публикации.
+   */
+  async #appendGitignore(paths) {
+    const file = path6.join(this.cwd, ".gitignore");
+    const existing = await readFile4(file, "utf8").catch(() => "");
+    const known = new Set(existing.split(/\r?\n/).map((line) => line.trim()));
+    const lines = paths.map(ignorePattern).filter((line) => !known.has(line));
+    if (lines.length === 0)
+      return;
+    const prefix = existing === "" || existing.endsWith("\n") ? "" : "\n";
+    await writeFile2(file, `${existing}${prefix}${lines.join("\n")}
+`, "utf8");
+  }
   /** Команда, чей провал — обычное дело (нет upstream, нет коммитов, detached). */
   async #soft(args) {
     return this.#run(args).catch(() => "");
   }
-  /** `input` — то, что команда читает со stdin; без него stdin сразу закрывается. */
-  #run(args, input) {
+  /**
+   * Запустить git.
+   *
+   * `input` — то, что команда читает со stdin; без него stdin сразу
+   * закрывается. `token` — учётные данные GitHub на одну команду (см.
+   * `credentialArgs`). `timeout` переопределяется у тех команд, что ходят в
+   * сеть: обычный потолок для них слишком мал.
+   */
+  #run(args, options2 = {}) {
+    const token = options2.token ?? "";
     return new Promise((resolve, reject) => {
       const child = execFile2(
         "git",
         // core.quotepath=false — иначе кириллические пути приезжают в виде
         // «\320\277\321\200…» и в панели читаются как мусор.
-        ["-c", "core.quotepath=false", ...args],
+        ["-c", "core.quotepath=false", ...credentialArgs(token), ...args],
         {
           cwd: this.cwd,
-          timeout: TIMEOUT_MS,
+          timeout: options2.timeout ?? TIMEOUT_MS,
           maxBuffer: MAX_BUFFER,
           windowsHide: true,
-          encoding: "utf8"
+          encoding: "utf8",
+          env: {
+            ...process.env,
+            // Токен уходит окружением, а не аргументом: аргументы видны в
+            // списке процессов любому пользователю машины.
+            ...token ? { CCV_GIT_TOKEN: token } : {},
+            // Хост не сидит в терминале: спроси git пароль — и он будет ждать
+            // ответа от stdin, которого никто не даст, до самого таймаута.
+            GIT_TERMINAL_PROMPT: "0"
+          }
         },
         (error, stdout, stderr) => {
           if (!error)
@@ -2486,10 +2668,20 @@ var GitRepo = class {
       );
       child.stdin?.on("error", () => {
       });
-      child.stdin?.end(input ?? "");
+      child.stdin?.end(options2.input ?? "");
     });
   }
 };
+function credentialArgs(token) {
+  if (!token)
+    return [];
+  return [
+    "-c",
+    "credential.helper=",
+    "-c",
+    'credential.helper=!f() { echo username=x-access-token; echo "password=$CCV_GIT_TOKEN"; }; f'
+  ];
+}
 function requireRef(value) {
   const trimmed = value.trim();
   if (!SAFE_REF.test(trimmed) || trimmed.includes("..")) {
@@ -2497,6 +2689,23 @@ function requireRef(value) {
   }
   return trimmed;
 }
+function requireUrl(value) {
+  const trimmed = value.trim();
+  if (!SAFE_URL.test(trimmed)) {
+    throw new Error(`\u041D\u0435 \u043F\u043E\u0445\u043E\u0436\u0435 \u043D\u0430 \u0430\u0434\u0440\u0435\u0441 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044F: \xAB${value}\xBB`);
+  }
+  return trimmed;
+}
+function requirePath(value) {
+  const trimmed = value.trim().replace(/\\/g, "/");
+  const bad = trimmed === "" || trimmed.startsWith("-") || trimmed.startsWith("/") || trimmed.includes(":") || trimmed.split("/").includes("..");
+  if (bad)
+    throw new Error(`\u041D\u0435\u0434\u043E\u043F\u0443\u0441\u0442\u0438\u043C\u044B\u0439 \u043F\u0443\u0442\u044C: \xAB${value}\xBB`);
+  return trimmed;
+}
+function ignorePattern(relPath) {
+  return `/${relPath.replace(/[\\*?[\]]/g, (char) => `\\${char}`)}`;
+}
 function describe2(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -2607,9 +2816,9 @@ function parsePatch(raw) {
       body = "";
     }
     total += body.length;
-    const path17 = status === "deleted" ? oldPath : newPath || oldPath;
+    const path19 = status === "deleted" ? oldPath : newPath || oldPath;
     files.push({
-      path: path17,
+      path: path19,
       oldPath: status === "renamed" ? oldPath : "",
       status,
       added: count(body, "+"),
@@ -2621,10 +2830,10 @@ function parsePatch(raw) {
   return { files, truncated };
 }
 function stripPrefix(value) {
-  const path17 = unquote(value.trim());
-  if (path17 === "/dev/null")
+  const path19 = unquote(value.trim());
+  if (path19 === "/dev/null")
     return "";
-  return path17.replace(/^[ab]\//, "");
+  return path19.replace(/^[ab]\//, "");
 }
 function count(body, mark) {
   let n = 0;
@@ -2635,11 +2844,241 @@ function count(body, mark) {
   return n;
 }
 
+// ../host/dist/github.js
+import { execFile as execFile3 } from "node:child_process";
+import { mkdir as mkdir2, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
+import path7 from "node:path";
+var API = "https://api.github.com";
+var API_VERSION = "2022-11-28";
+var API_TIMEOUT_MS = 2e4;
+var GH_TIMEOUT_MS = 15e3;
+var ORG_LIMIT = 100;
+var GitHubAccount = class {
+  #storePath;
+  #token = "";
+  /**
+   * Есть ли `gh` в PATH. `null` — ещё не проверяли.
+   *
+   * Промах не запоминается навсегда по той же причине, что и в поиске `claude`
+   * (см. [`claude-cli.ts`](./claude-cli.ts)): CLI могли поставить уже после
+   * запуска хоста, и требовать за это перезапуск было бы грубо. Здесь для
+   * этого хватает сброса при каждом чтении статуса — его спрашивают тогда,
+   * когда человек стоит перед окном публикации и готов подождать одну попытку
+   * запуска процесса.
+   */
+  #ghInstalled = null;
+  constructor(dataDir) {
+    this.#storePath = path7.join(dataDir, "github.json");
+  }
+  async load() {
+    try {
+      const raw = JSON.parse(await readFile5(this.#storePath, "utf8"));
+      const token = raw.token;
+      this.#token = typeof token === "string" ? token.trim() : "";
+    } catch {
+      this.#token = "";
+    }
+  }
+  /** Сохранить токен или стереть его пустой строкой. */
+  async setToken(token) {
+    this.#token = token.trim();
+    await mkdir2(path7.dirname(this.#storePath), { recursive: true });
+    await writeFile3(this.#storePath, JSON.stringify({ token: this.#token }, null, 2), {
+      encoding: "utf8",
+      mode: 384
+    });
+  }
+  /**
+   * Кто подключён.
+   *
+   * Не «есть ли токен», а «принял ли его GitHub»: просроченный или отозванный
+   * токен лежит в файле ровно так же, как рабочий, и разница видна только по
+   * ответу на запрос. Поэтому здесь всегда поход в сеть — зато окно публикации
+   * не предложит создать репозиторий тем, чем создать его не выйдет.
+   */
+  async status() {
+    const ghInstalled = await this.#hasGh();
+    const base = {
+      connected: false,
+      source: "none",
+      login: "",
+      ghInstalled,
+      hasToken: this.#token !== "",
+      message: ""
+    };
+    try {
+      const credential = await this.credential();
+      return { ...base, connected: true, source: credential.source, login: credential.login };
+    } catch (error) {
+      return { ...base, message: describe3(error) };
+    }
+  }
+  /**
+   * Чем работать с GitHub. Бросает, если ни один источник не подошёл.
+   *
+   * Логин приходит тем же запросом, что и проверка токена: `GET /user` всё
+   * равно единственный способ узнать, жив ли токен, и спрашивать имя вторым
+   * запросом было бы лишним походом в сеть за тем, что уже пришло.
+   */
+  async credential() {
+    const ghToken = await this.#ghToken();
+    if (ghToken) {
+      const login = await this.#login(ghToken).catch(() => "");
+      if (login)
+        return { token: ghToken, source: "gh", login };
+    }
+    if (this.#token) {
+      const login = await this.#login(this.#token);
+      return { token: this.#token, source: "token", login };
+    }
+    throw new Error(ghToken ? "GitHub CLI \u0431\u043E\u043B\u044C\u0448\u0435 \u043D\u0435 \u0430\u0432\u0442\u043E\u0440\u0438\u0437\u043E\u0432\u0430\u043D \u2014 \u0432\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u0435 `gh auth login` \u0438\u043B\u0438 \u0432\u0432\u0435\u0434\u0438\u0442\u0435 \u0442\u043E\u043A\u0435\u043D" : "\u041D\u0435\u0442 \u0434\u043E\u0441\u0442\u0443\u043F\u0430 \u043A GitHub \u2014 \u0432\u0432\u0435\u0434\u0438\u0442\u0435 \u0442\u043E\u043A\u0435\u043D \u0438\u043B\u0438 \u0432\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u0435 `gh auth login`");
+  }
+  /**
+   * Куда можно создать репозиторий: сам пользователь и его организации.
+   *
+   * Организации, в которых нет права заводить репозитории, GitHub всё равно
+   * вернёт — прав он по этому запросу не сообщает. Отсеивать их здесь нечем, и
+   * ошибку в таком случае показывает уже создание: она приходит от GitHub
+   * текстом, который объясняет причину лучше, чем наша догадка.
+   */
+  async owners() {
+    const { token, login } = await this.credential();
+    const orgs = await this.#api(token, `/user/orgs?per_page=${ORG_LIMIT}`).catch(
+      // Токен без scope `read:org` организаций не покажет. Это не повод не дать
+      // создать репозиторий у себя — а именно это и нужно в большинстве случаев.
+      () => []
+    );
+    return [
+      { login, kind: "user" },
+      ...orgs.map((org) => typeof org.login === "string" ? org.login : "").filter(Boolean).map((org) => ({ login: org, kind: "org" }))
+    ];
+  }
+  /**
+   * Создать репозиторий.
+   *
+   * Пустой — без README, .gitignore и лицензии: у нас на диске уже лежит
+   * проект, и любой файл, созданный на стороне GitHub, превратил бы первый же
+   * push в конфликт историй.
+   */
+  async createRepo(options2) {
+    const { token, login } = await this.credential();
+    const endpoint = options2.owner === login ? "/user/repos" : `/orgs/${encodeURIComponent(options2.owner)}/repos`;
+    const created = await this.#api(token, endpoint, {
+      method: "POST",
+      body: {
+        name: options2.name,
+        description: options2.description,
+        private: options2.private,
+        auto_init: false
+      }
+    });
+    const cloneUrl = str(created.clone_url);
+    if (!cloneUrl)
+      throw new Error("GitHub \u0441\u043E\u0437\u0434\u0430\u043B \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0439, \u043D\u043E \u043D\u0435 \u0432\u0435\u0440\u043D\u0443\u043B \u0430\u0434\u0440\u0435\u0441 \u0434\u043B\u044F git");
+    return {
+      cloneUrl,
+      htmlUrl: str(created.html_url) || cloneUrl.replace(/\.git$/, ""),
+      fullName: str(created.full_name) || `${options2.owner}/${options2.name}`
+    };
+  }
+  // ---------------------------------------------------------------- внутреннее
+  /** Логин владельца токена; заодно это и есть проверка токена на живость. */
+  async #login(token) {
+    const user = await this.#api(token, "/user");
+    const login = str(user.login);
+    if (!login)
+      throw new Error("GitHub \u043D\u0435 \u043D\u0430\u0437\u0432\u0430\u043B \u0443\u0447\u0451\u0442\u043D\u0443\u044E \u0437\u0430\u043F\u0438\u0441\u044C \u2014 \u0442\u043E\u043A\u0435\u043D \u043D\u0435 \u043F\u043E\u0434\u043E\u0448\u0451\u043B");
+    return login;
+  }
+  async #api(token, endpoint, init) {
+    let response;
+    try {
+      response = await fetch(`${API}${endpoint}`, {
+        method: init?.method ?? "GET",
+        headers: {
+          Accept: "application/vnd.github+json",
+          Authorization: `Bearer ${token}`,
+          "X-GitHub-Api-Version": API_VERSION,
+          // GitHub отвечает 403 на запрос без User-Agent — это его требование,
+          // а не вежливость.
+          "User-Agent": "claude-code-visual",
+          ...init ? { "Content-Type": "application/json" } : {}
+        },
+        body: init ? JSON.stringify(init.body) : void 0,
+        signal: AbortSignal.timeout(API_TIMEOUT_MS)
+      });
+    } catch (error) {
+      throw new Error(`GitHub \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D: ${describe3(error)}`);
+    }
+    const text = await response.text();
+    if (!response.ok)
+      throw new Error(apiError(response.status, text));
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new Error(`GitHub \u043E\u0442\u0432\u0435\u0442\u0438\u043B \u043D\u0435 JSON (${response.status})`);
+    }
+  }
+  /** Токен GitHub CLI; пустая строка — `gh` нет или вход в нём не выполнен. */
+  async #ghToken() {
+    if (this.#ghInstalled === false)
+      return "";
+    const token = await gh(["auth", "token"]).catch(() => "");
+    return token.trim();
+  }
+  async #hasGh() {
+    const version2 = await gh(["--version"]).catch(() => "");
+    this.#ghInstalled = version2 !== "";
+    return this.#ghInstalled;
+  }
+};
+function gh(args) {
+  return new Promise((resolve, reject) => {
+    execFile3("gh", args, { timeout: GH_TIMEOUT_MS, windowsHide: true, encoding: "utf8" }, (error, stdout, stderr) => {
+      if (error)
+        return reject(new Error(stderr.trim() || error.message));
+      resolve(stdout);
+    });
+  });
+}
+function apiError(status, body) {
+  let message = "";
+  let details = "";
+  try {
+    const parsed = JSON.parse(body);
+    message = str(parsed.message);
+    if (Array.isArray(parsed.errors)) {
+      details = parsed.errors.map((item) => str(item.message)).filter(Boolean).join("; ");
+    }
+  } catch {
+    message = body.slice(0, 200).trim();
+  }
+  const text = [message, details].filter(Boolean).join(" \u2014 ");
+  switch (status) {
+    case 401:
+      return "GitHub \u043E\u0442\u043A\u043B\u043E\u043D\u0438\u043B \u0442\u043E\u043A\u0435\u043D (401) \u2014 \u043E\u043D \u0438\u0441\u0442\u0451\u043A \u0438\u043B\u0438 \u043E\u0442\u043E\u0437\u0432\u0430\u043D";
+    case 403:
+      return `GitHub \u043E\u0442\u043A\u0430\u0437\u0430\u043B (403): ${text || "\u043D\u0435\u0442 \u043F\u0440\u0430\u0432 \u0438\u043B\u0438 \u043F\u0440\u0435\u0432\u044B\u0448\u0435\u043D \u043B\u0438\u043C\u0438\u0442 \u0437\u0430\u043F\u0440\u043E\u0441\u043E\u0432"}`;
+    case 404:
+      return `GitHub \u043E\u0442\u0432\u0435\u0442\u0438\u043B 404: ${text || "\u043D\u0435\u0442 \u0442\u0430\u043A\u043E\u0439 \u043E\u0440\u0433\u0430\u043D\u0438\u0437\u0430\u0446\u0438\u0438 \u0438\u043B\u0438 \u0443 \u0442\u043E\u043A\u0435\u043D\u0430 \u043D\u0435\u0442 \u043F\u0440\u0430\u0432 \u043D\u0430 \u043D\u0435\u0451"}`;
+    case 422:
+      return `GitHub \u043E\u0442\u043A\u0430\u0437\u0430\u043B\u0441\u044F \u0441\u043E\u0437\u0434\u0430\u0432\u0430\u0442\u044C: ${text || "\u0442\u0430\u043A\u043E\u0435 \u0438\u043C\u044F \u0443\u0436\u0435 \u0437\u0430\u043D\u044F\u0442\u043E"}`;
+    default:
+      return `GitHub \u043E\u0442\u0432\u0435\u0442\u0438\u043B ${status}${text ? `: ${text}` : ""}`;
+  }
+}
+function str(value) {
+  return typeof value === "string" ? value : "";
+}
+function describe3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // ../host/dist/finder.js
 import { existsSync, statSync } from "node:fs";
 import { readdir as readdir2 } from "node:fs/promises";
 import os2 from "node:os";
-import path6 from "node:path";
+import path8 from "node:path";
 import { listSessions } from "@anthropic-ai/claude-agent-sdk";
 var CACHE_TTL = 6e4;
 var FIND_LIMIT = 50;
@@ -2678,7 +3117,7 @@ var ProjectFinder = class {
     if (needles.length === 0)
       return { candidates: [], truncated: false };
     const open = new Map(this.registry.list().map((workspace) => [workspace.path.toLowerCase(), workspace]));
-    const byName = this.#dirs.filter((dir) => matches(path6.basename(dir.path), needles));
+    const byName = this.#dirs.filter((dir) => matches(path8.basename(dir.path), needles));
     const matched = byName.length > 0 ? byName : this.#dirs.filter((dir) => matches(dir.path, needles));
     const sorted = [...matched].sort((a, b) => {
       const aOpen = open.has(a.path.toLowerCase());
@@ -2689,7 +3128,7 @@ var ProjectFinder = class {
         return a.sessions > 0 ? -1 : 1;
       if (a.lastUsedAt !== b.lastUsedAt)
         return b.lastUsedAt - a.lastUsedAt;
-      return path6.basename(a.path).localeCompare(path6.basename(b.path), void 0, {
+      return path8.basename(a.path).localeCompare(path8.basename(b.path), void 0, {
         numeric: true,
         sensitivity: "base"
       });
@@ -2697,7 +3136,7 @@ var ProjectFinder = class {
     return {
       candidates: sorted.slice(0, FIND_LIMIT).map((dir) => ({
         path: dir.path,
-        name: path6.basename(dir.path) || dir.path,
+        name: path8.basename(dir.path) || dir.path,
         sessions: dir.sessions,
         lastUsedAt: dir.lastUsedAt || null,
         open: open.has(dir.path.toLowerCase()),
@@ -2721,7 +3160,7 @@ var ProjectFinder = class {
     const candidates = [];
     for (const entry of named) {
       const absolute = entry.path.trim();
-      if (!absolute || !path6.isAbsolute(absolute))
+      if (!absolute || !path8.isAbsolute(absolute))
         continue;
       const key = absolute.toLowerCase();
       if (seen.has(key))
@@ -2732,7 +3171,7 @@ var ProjectFinder = class {
       const record = known.get(key);
       candidates.push({
         path: record?.path ?? absolute,
-        name: path6.basename(absolute) || absolute,
+        name: path8.basename(absolute) || absolute,
         sessions: record?.sessions ?? 0,
         lastUsedAt: record?.lastUsedAt || null,
         open: open.has(key),
@@ -2789,7 +3228,7 @@ var ProjectFinder = class {
         if (!dirent.isDirectory() || SKIP_NAMES.has(dirent.name) || dirent.name.startsWith(".")) {
           continue;
         }
-        const full = path6.join(parent, dirent.name);
+        const full = path8.join(parent, dirent.name);
         const key = full.toLowerCase();
         if (dirs.has(key))
           continue;
@@ -2810,7 +3249,7 @@ var ProjectFinder = class {
   #parents(dirs) {
     const counted = /* @__PURE__ */ new Map();
     for (const dir of dirs) {
-      const parent = path6.dirname(dir.path);
+      const parent = path8.dirname(dir.path);
       if (parent === dir.path || !usable(parent))
         continue;
       const key = parent.toLowerCase();
@@ -2922,18 +3361,18 @@ function fromText(text) {
 
 // ../host/dist/workspaces.js
 import { existsSync as existsSync2, statSync as statSync2 } from "node:fs";
-import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
-import path7 from "node:path";
+import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
+import path9 from "node:path";
 import { listSessions as listSessions2 } from "@anthropic-ai/claude-agent-sdk";
 var WorkspaceRegistry = class {
   #paths = [];
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path7.join(dataDir, "workspaces.json");
+    this.#storePath = path9.join(dataDir, "workspaces.json");
   }
   async load() {
     try {
-      const raw = await readFile4(this.#storePath, "utf8");
+      const raw = await readFile6(this.#storePath, "utf8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed)) {
         this.#paths = parsed.filter((p) => typeof p === "string" && existsSync2(p));
@@ -2943,8 +3382,8 @@ var WorkspaceRegistry = class {
     }
   }
   async #persist() {
-    await mkdir2(path7.dirname(this.#storePath), { recursive: true });
-    await writeFile2(this.#storePath, JSON.stringify(this.#paths, null, 2), "utf8");
+    await mkdir3(path9.dirname(this.#storePath), { recursive: true });
+    await writeFile4(this.#storePath, JSON.stringify(this.#paths, null, 2), "utf8");
   }
   list() {
     return this.#paths.map(toInfo);
@@ -2953,7 +3392,7 @@ var WorkspaceRegistry = class {
     return this.list().find((w) => w.id === id);
   }
   async open(rawPath) {
-    const absolute = path7.resolve(rawPath);
+    const absolute = path9.resolve(rawPath);
     if (!existsSync2(absolute)) {
       throw new Error(`\u041A\u0430\u0442\u0430\u043B\u043E\u0433 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: ${absolute}`);
     }
@@ -2995,24 +3434,24 @@ var WorkspaceRegistry = class {
   async create(parentRaw, nameRaw, init) {
     const name = nameRaw.trim();
     requireName(name);
-    const parent = path7.resolve(parentRaw.trim());
+    const parent = path9.resolve(parentRaw.trim());
     if (!existsSync2(parent)) {
       throw new Error(`\u041A\u0430\u0442\u0430\u043B\u043E\u0433 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: ${parent}`);
     }
     if (!statSync2(parent).isDirectory()) {
       throw new Error(`\u042D\u0442\u043E \u043D\u0435 \u043A\u0430\u0442\u0430\u043B\u043E\u0433: ${parent}`);
     }
-    const target = path7.join(parent, name);
+    const target = path9.join(parent, name);
     if (existsSync2(target)) {
       throw new Error(`\u0423\u0436\u0435 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u0435\u0442: ${target} \u2014 \u043E\u0442\u043A\u0440\u043E\u0439\u0442\u0435 \u0435\u0433\u043E \u043A\u0430\u043A \u043F\u0440\u043E\u0435\u043A\u0442`);
     }
-    await mkdir2(target);
+    await mkdir3(target);
     const warnings = [];
     if (init.claudeMd) {
-      await step(warnings, "CLAUDE.md", () => writeFile2(path7.join(target, "CLAUDE.md"), claudeMdStub(name), "utf8"));
+      await step(warnings, "CLAUDE.md", () => writeFile4(path9.join(target, "CLAUDE.md"), claudeMdStub(name), "utf8"));
     }
     if (init.readme) {
-      await step(warnings, "README.md", () => writeFile2(path7.join(target, "README.md"), readmeStub(name), "utf8"));
+      await step(warnings, "README.md", () => writeFile4(path9.join(target, "README.md"), readmeStub(name), "utf8"));
     }
     if (init.git) {
       await step(warnings, "git init", () => new GitRepo(target).init());
@@ -3083,24 +3522,24 @@ function toInfo(absolute) {
   return {
     id: workspaceIdFromPath(absolute),
     path: absolute,
-    name: path7.basename(absolute) || absolute,
-    hasClaudeMd: existsSync2(path7.join(absolute, "CLAUDE.md"))
+    name: path9.basename(absolute) || absolute,
+    hasClaudeMd: existsSync2(path9.join(absolute, "CLAUDE.md"))
   };
 }
 
 // ../host/dist/archive.js
-import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
-import path8 from "node:path";
+import { mkdir as mkdir4, readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
+import path10 from "node:path";
 var SessionArchive = class {
   #archived = /* @__PURE__ */ new Map();
   #restored = /* @__PURE__ */ new Map();
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path8.join(dataDir, "session-archive.json");
+    this.#storePath = path10.join(dataDir, "session-archive.json");
   }
   async load() {
     try {
-      const raw = await readFile5(this.#storePath, "utf8");
+      const raw = await readFile7(this.#storePath, "utf8");
       const parsed = JSON.parse(raw);
       this.#archived = new Map(Object.entries(parsed.archived ?? {}).filter(([, r]) => isRecord(r)));
       this.#restored = new Map(Object.entries(parsed.restored ?? {}).filter((entry) => typeof entry[1] === "number"));
@@ -3189,8 +3628,8 @@ var SessionArchive = class {
       archived: Object.fromEntries(this.#archived),
       restored: Object.fromEntries(this.#restored)
     };
-    await mkdir3(path8.dirname(this.#storePath), { recursive: true });
-    await writeFile3(this.#storePath, JSON.stringify(file, null, 2), "utf8");
+    await mkdir4(path10.dirname(this.#storePath), { recursive: true });
+    await writeFile5(this.#storePath, JSON.stringify(file, null, 2), "utf8");
   }
 };
 function isRecord(value) {
@@ -3198,17 +3637,17 @@ function isRecord(value) {
 }
 
 // ../host/dist/pins.js
-import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
-import path9 from "node:path";
+import { mkdir as mkdir5, readFile as readFile8, writeFile as writeFile6 } from "node:fs/promises";
+import path11 from "node:path";
 var SessionPins = class {
   #pinned = /* @__PURE__ */ new Map();
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path9.join(dataDir, "session-pins.json");
+    this.#storePath = path11.join(dataDir, "session-pins.json");
   }
   async load() {
     try {
-      const raw = await readFile6(this.#storePath, "utf8");
+      const raw = await readFile8(this.#storePath, "utf8");
       const parsed = JSON.parse(raw);
       this.#pinned = new Map(Object.entries(parsed.pinned ?? {}).filter(([, r]) => isRecord2(r)));
     } catch {
@@ -3306,8 +3745,8 @@ var SessionPins = class {
   }
   async #persist() {
     const file = { pinned: Object.fromEntries(this.#pinned) };
-    await mkdir4(path9.dirname(this.#storePath), { recursive: true });
-    await writeFile4(this.#storePath, JSON.stringify(file, null, 2), "utf8");
+    await mkdir5(path11.dirname(this.#storePath), { recursive: true });
+    await writeFile6(this.#storePath, JSON.stringify(file, null, 2), "utf8");
   }
 };
 function isRecord2(value) {
@@ -3315,9 +3754,9 @@ function isRecord2(value) {
 }
 
 // ../host/dist/app-settings.js
-import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir6, readFile as readFile9, writeFile as writeFile7 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import path10 from "node:path";
+import path12 from "node:path";
 var DEFAULT_AUTO_ARCHIVE_AFTER_MS = 2 * 24 * 60 * 60 * 1e3;
 var MIN_AUTO_ARCHIVE_AFTER_MS = 60 * 60 * 1e3;
 var MIN_AUTO_SAVE_AFTER_PAUSE_MS = 500;
@@ -3352,11 +3791,11 @@ var AppSettingsStore = class {
   #settings = { ...DEFAULT_APP_SETTINGS };
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path10.join(dataDir, "app-settings.json");
+    this.#storePath = path12.join(dataDir, "app-settings.json");
   }
   async load() {
     try {
-      const raw = await readFile7(this.#storePath, "utf8");
+      const raw = await readFile9(this.#storePath, "utf8");
       this.#settings = sanitize(JSON.parse(raw), DEFAULT_APP_SETTINGS);
     } catch {
       this.#settings = { ...DEFAULT_APP_SETTINGS };
@@ -3376,8 +3815,8 @@ var AppSettingsStore = class {
   async update(patch) {
     const next = sanitize(patch, this.#settings);
     this.#settings = next;
-    await mkdir5(path10.dirname(this.#storePath), { recursive: true });
-    await writeFile5(this.#storePath, JSON.stringify(next, null, 2), "utf8");
+    await mkdir6(path12.dirname(this.#storePath), { recursive: true });
+    await writeFile7(this.#storePath, JSON.stringify(next, null, 2), "utf8");
     return this.current;
   }
 };
@@ -3415,7 +3854,7 @@ function sanitize(value, fallback) {
   return result;
 }
 function claudeHome() {
-  return path10.join(homedir3(), ".claude");
+  return path12.join(homedir3(), ".claude");
 }
 function writableRoots(mode, cwd, workspacePaths) {
   if (mode === "all")
@@ -3425,7 +3864,7 @@ function writableRoots(mode, cwd, workspacePaths) {
     return [...roots];
   for (const workspace of [cwd, ...workspacePaths]) {
     roots.add(workspace);
-    const parent = path10.dirname(workspace);
+    const parent = path12.dirname(workspace);
     if (parent !== workspace)
       roots.add(parent);
   }
@@ -3433,9 +3872,9 @@ function writableRoots(mode, cwd, workspacePaths) {
 }
 
 // ../host/dist/plugins.js
-import { readFile as readFile8 } from "node:fs/promises";
+import { readFile as readFile10 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import path11 from "node:path";
+import path13 from "node:path";
 var TIMEOUT_MS2 = 12e4;
 var SAFE_ARG = /^[A-Za-z0-9][A-Za-z0-9._@/-]*$/;
 var PluginCli = class {
@@ -3534,10 +3973,10 @@ async function readCatalog(markets, installed) {
   return lists.flat().sort((a, b) => a.name.localeCompare(b.name));
 }
 async function readMarketplace(market, installed) {
-  const root = market.installLocation || path11.join(homedir4(), ".claude", "plugins", "marketplaces", market.name);
+  const root = market.installLocation || path13.join(homedir4(), ".claude", "plugins", "marketplaces", market.name);
   let manifest;
   try {
-    const text = await readFile8(path11.join(root, ".claude-plugin", "marketplace.json"), "utf8");
+    const text = await readFile10(path13.join(root, ".claude-plugin", "marketplace.json"), "utf8");
     manifest = JSON.parse(text);
   } catch {
     return [];
@@ -3624,7 +4063,7 @@ var AuthCli = class extends EventEmitter2 {
     if (this.#child)
       throw new Error("\u0412\u0445\u043E\u0434 \u0443\u0436\u0435 \u0438\u0434\u0451\u0442 \u2014 \u0434\u043E\u0436\u0434\u0438\u0442\u0435\u0441\u044C \u0438\u043B\u0438 \u043E\u0442\u043C\u0435\u043D\u0438\u0442\u0435 \u0435\u0433\u043E");
     if (switchAccount) {
-      const out = await run(["auth", "logout"], QUICK_TIMEOUT_MS).catch(describe3);
+      const out = await run(["auth", "logout"], QUICK_TIMEOUT_MS).catch(describe4);
       this.#push({ ...IDLE, active: true, output: `${out}
 ` });
       this.emit("changed");
@@ -3644,7 +4083,7 @@ var AuthCli = class extends EventEmitter2 {
     child.stdout?.on("data", (chunk) => this.#absorb(chunk.toString()));
     child.stderr?.on("data", (chunk) => this.#absorb(chunk.toString()));
     child.on("error", (error) => {
-      this.#fail(error.code === "ENOENT" ? "\u041D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D claude \u0432 PATH \u2014 \u0432\u0445\u043E\u0434 \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D" : describe3(error));
+      this.#fail(error.code === "ENOENT" ? "\u041D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D claude \u0432 PATH \u2014 \u0432\u0445\u043E\u0434 \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D" : describe4(error));
     });
     child.on("close", (code) => {
       if (this.#child !== child)
@@ -3659,14 +4098,20 @@ var AuthCli = class extends EventEmitter2 {
       this.emit("changed");
     });
   }
-  /** Отдать процессу код, принесённый из браузера. */
+  /**
+   * Отдать процессу код, принесённый из браузера.
+   *
+   * `awaitingCode` намеренно остаётся поднятым: отправка кода не конец входа, а
+   * попытка. CLI отвечает на неё либо успехом и выходом (тогда поле уберёт
+   * `close`), либо строкой «Invalid code» — и во втором случае человеку нужно то
+   * же самое поле, чтобы вставить код целиком.
+   */
   submitCode(code) {
     const child = this.#child;
     if (!child?.stdin?.writable)
       throw new Error("\u0412\u0445\u043E\u0434 \u043D\u0435 \u0438\u0434\u0451\u0442 \u2014 \u0432\u0432\u043E\u0434\u0438\u0442\u044C \u043A\u043E\u0434 \u043D\u0435\u043A\u0443\u0434\u0430");
-    child.stdin.write(`${code.trim()}
+    child.stdin.write(`${normalizeAuthCode(code)}
 `);
-    this.#push({ ...this.#state, awaitingCode: false });
   }
   /** Прервать вход. Учётные данные при этом остаются прежними. */
   cancel() {
@@ -3691,7 +4136,14 @@ var AuthCli = class extends EventEmitter2 {
       url: this.#state.url || URL_RE.exec(output)?.[0] || "",
       // Приглашение ищем в хвосте: раньше в выводе оно встретиться не может, а
       // так мы не примем за него упоминание кода в старом сообщении.
-      awaitingCode: CODE_PROMPT_RE.test(output.slice(-200))
+      //
+      // И не гасим его обратно: приглашение CLI печатает ровно один раз, а
+      // читает строки со stdin до самого конца входа. Отвяжи мы поле от этой
+      // однократной печати — первый же неверный код («Invalid code…» в хвосте
+      // перестаёт подходить под выражение) убирал бы поле с экрана, и
+      // исправить опечатку стало бы негде: вход ещё идёт, а ввести в него
+      // нечего.
+      awaitingCode: this.#state.awaitingCode || CODE_PROMPT_RE.test(output.slice(-200))
     });
   }
   #fail(message) {
@@ -3713,6 +4165,23 @@ var AuthCli = class extends EventEmitter2 {
 function run(args, timeout) {
   return runClaude(args, { timeout, missing: "\u0443\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u0435 \u0430\u043A\u043A\u0430\u0443\u043D\u0442\u043E\u043C \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u043E" });
 }
+function normalizeAuthCode(raw) {
+  const value = raw.trim();
+  if (!/^https?:\/\//i.test(value))
+    return value;
+  let url2;
+  try {
+    url2 = new URL(value);
+  } catch {
+    return value;
+  }
+  const params = new URLSearchParams(url2.search.slice(1) || url2.hash.replace(/^#/, ""));
+  const code = params.get("code");
+  const state = params.get("state");
+  if (!code)
+    return value;
+  return state ? `${code}#${state}` : code;
+}
 function parseStatus2(raw) {
   const empty = {
     loggedIn: false,
@@ -3733,23 +4202,23 @@ function parseStatus2(raw) {
   }
   return {
     loggedIn: parsed.loggedIn === true,
-    method: str(parsed.authMethod) || "none",
-    email: str(parsed.email),
-    organization: str(parsed.orgName),
-    plan: str(parsed.subscriptionType)
+    method: str2(parsed.authMethod) || "none",
+    email: str2(parsed.email),
+    organization: str2(parsed.orgName),
+    plan: str2(parsed.subscriptionType)
   };
 }
-function str(value) {
+function str2(value) {
   return typeof value === "string" ? value : "";
 }
-function describe3(error) {
+function describe4(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
 // ../host/dist/relay-link.js
 import { EventEmitter as EventEmitter3 } from "node:events";
-import { readFile as readFile9, writeFile as writeFile6, rm as rm2, mkdir as mkdir6 } from "node:fs/promises";
-import path12 from "node:path";
+import { readFile as readFile11, writeFile as writeFile8, rm as rm3, mkdir as mkdir7 } from "node:fs/promises";
+import path14 from "node:path";
 import { hostname } from "node:os";
 import WebSocket from "ws";
 
@@ -3760,6 +4229,9 @@ var RELAY_BROADCAST = "*";
 // ../host/dist/relay-link.js
 var RETRY_MIN_MS = 1e3;
 var RETRY_MAX_MS = 6e4;
+var HANDSHAKE_TIMEOUT_MS = 15e3;
+var CONNECT_TIMEOUT_MS = 3e4;
+var SILENCE_TIMEOUT_MS = 95e3;
 function jitter(delay) {
   return Math.round(delay * (0.8 + Math.random() * 0.4));
 }
@@ -3768,6 +4240,17 @@ var RelayLink = class extends EventEmitter3 {
   #socket = null;
   #retry = RETRY_MIN_MS;
   #retryTimer = null;
+  /**
+   * Сторож живого соединения — один таймер на три фазы жизни сокета.
+   *
+   * До `open` он сторожит подключение, после — тишину, и переставляется каждым
+   * пришедшим кадром. Один таймер, а не три: у сокета в каждый момент есть
+   * ровно один способ подвести, и держать под него отдельные заводные механизмы
+   * значило бы гасить их по очереди в каждой ветке.
+   */
+  #watchdog = null;
+  /** Сокет рвём мы сами — чтобы не подменить свою причину отказа причиной от `ws`. */
+  #aborting = false;
   #clients = /* @__PURE__ */ new Set();
   #error = null;
   #closed = false;
@@ -3790,7 +4273,7 @@ var RelayLink = class extends EventEmitter3 {
   #log;
   constructor(options2) {
     super();
-    this.#file = path12.join(options2.dataDir, "relay.json");
+    this.#file = path14.join(options2.dataDir, "relay.json");
     this.#defaultUrl = options2.defaultUrl.replace(/\/+$/, "");
     this.#log = options2.log ?? ((msg) => console.log(`[relay] ${msg}`));
   }
@@ -3871,7 +4354,7 @@ var RelayLink = class extends EventEmitter3 {
   }
   async #read() {
     try {
-      const raw = await readFile9(this.#file, "utf8");
+      const raw = await readFile11(this.#file, "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed !== "object" || parsed === null)
         return null;
@@ -3884,8 +4367,8 @@ var RelayLink = class extends EventEmitter3 {
     }
   }
   async #write(credentials) {
-    await mkdir6(path12.dirname(this.#file), { recursive: true });
-    await writeFile6(this.#file, `${JSON.stringify(credentials, null, 2)}
+    await mkdir7(path14.dirname(this.#file), { recursive: true });
+    await writeFile8(this.#file, `${JSON.stringify(credentials, null, 2)}
 `, {
       encoding: "utf8",
       mode: 384
@@ -3909,7 +4392,7 @@ var RelayLink = class extends EventEmitter3 {
         body: JSON.stringify({ code, name: machine, platform: process.platform })
       });
     } catch (error) {
-      throw new Error(`\u043D\u0435 \u0434\u043E\u0437\u0432\u043E\u043D\u0438\u043B\u0438\u0441\u044C \u0434\u043E ${url2}: ${describe4(error)}`);
+      throw new Error(`\u043D\u0435 \u0434\u043E\u0437\u0432\u043E\u043D\u0438\u043B\u0438\u0441\u044C \u0434\u043E ${url2}: ${describe5(error)}`);
     }
     const data = await response.json().catch(() => ({}));
     if (!response.ok || !data.token || !data.hostId) {
@@ -3937,7 +4420,7 @@ var RelayLink = class extends EventEmitter3 {
     this.#error = null;
     this.#clients.clear();
     this.#shell = { enabled: false, pending: false, email: null, confirmedAt: null };
-    await rm2(this.#file, { force: true });
+    await rm3(this.#file, { force: true });
     this.#changed();
     this.#log("\u0441\u043E\u043F\u0440\u044F\u0436\u0435\u043D\u0438\u0435 \u0441\u043D\u044F\u0442\u043E");
   }
@@ -3953,10 +4436,13 @@ var RelayLink = class extends EventEmitter3 {
       clearTimeout(this.#retryTimer);
       this.#retryTimer = null;
     }
+    this.#disarm();
     const socket = this.#socket;
     this.#socket = null;
     if (socket) {
       socket.removeAllListeners();
+      socket.on("error", () => {
+      });
       socket.close();
     }
     for (const clientId of this.#clients)
@@ -3968,9 +4454,12 @@ var RelayLink = class extends EventEmitter3 {
     if (!credentials || this.#closed || this.#socket)
       return;
     const wsUrl = `${credentials.url.replace(/^http/, "ws")}/relay/host`;
-    const socket = new WebSocket(wsUrl);
+    this.#aborting = false;
+    const socket = new WebSocket(wsUrl, { handshakeTimeout: HANDSHAKE_TIMEOUT_MS });
     this.#socket = socket;
+    this.#arm(socket, CONNECT_TIMEOUT_MS, "relay \u043D\u0435 \u043E\u0442\u0432\u0435\u0442\u0438\u043B \u043D\u0430 \u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u0435");
     socket.on("open", () => {
+      this.#arm(socket, SILENCE_TIMEOUT_MS, "relay \u0437\u0430\u043C\u043E\u043B\u0447\u0430\u043B");
       const hello = {
         t: "host.hello",
         protocol: RELAY_PROTOCOL_VERSION,
@@ -3980,13 +4469,19 @@ var RelayLink = class extends EventEmitter3 {
       };
       socket.send(JSON.stringify(hello));
     });
-    socket.on("message", (raw) => this.#onMessage(socket, String(raw)));
+    socket.on("message", (raw) => {
+      this.#arm(socket, SILENCE_TIMEOUT_MS, "relay \u0437\u0430\u043C\u043E\u043B\u0447\u0430\u043B");
+      this.#onMessage(socket, String(raw));
+    });
     socket.on("error", (error) => {
-      this.#error = describe4(error);
+      if (this.#aborting)
+        return;
+      this.#error = humanize(error);
     });
     socket.on("close", (code, reason) => {
       if (this.#socket !== socket)
         return;
+      this.#disarm();
       this.#socket = null;
       for (const clientId of this.#clients)
         this.emit("detached", clientId);
@@ -4000,6 +4495,34 @@ var RelayLink = class extends EventEmitter3 {
       this.#scheduleRetry(rejected);
     });
   }
+  /**
+   * Взвести сторожа: не дождались — рвём сокет и уходим на общий круг повтора.
+   *
+   * `terminate()`, а не `close()`: закрытие по правилам ждёт ответного кадра от
+   * стороны, которая как раз и не отвечает, — а нам нужен `close` на своей
+   * стороне здесь и сейчас, потому что именно он запускает переподключение.
+   * Для сокета, застрявшего в CONNECTING, `ws` тем же вызовом обрывает
+   * рукопожатие — и это тот самый случай, ради которого всё написано.
+   */
+  #arm(socket, ms, reason) {
+    this.#disarm();
+    this.#watchdog = setTimeout(() => {
+      this.#watchdog = null;
+      if (this.#socket !== socket)
+        return;
+      this.#error = `${reason} \u0437\u0430 ${Math.round(ms / 1e3)} \u0441 \u2014 \u043F\u0440\u043E\u0431\u0443\u0435\u043C \u0441\u043D\u043E\u0432\u0430`;
+      this.#log(this.#error);
+      this.#aborting = true;
+      socket.terminate();
+    }, ms);
+    this.#watchdog.unref();
+  }
+  #disarm() {
+    if (!this.#watchdog)
+      return;
+    clearTimeout(this.#watchdog);
+    this.#watchdog = null;
+  }
   #scheduleRetry(rejected) {
     if (this.#closed || !this.#credentials || this.#retryTimer)
       return;
@@ -4088,14 +4611,21 @@ var RelayLink = class extends EventEmitter3 {
     socket.send(JSON.stringify(frame));
   }
 };
-function describe4(error) {
+function describe5(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function humanize(error) {
+  const message = describe5(error);
+  if (/handshake has timed out/i.test(message)) {
+    return `relay \u043D\u0435 \u043E\u0442\u0432\u0435\u0442\u0438\u043B \u043D\u0430 \u0440\u0443\u043A\u043E\u043F\u043E\u0436\u0430\u0442\u0438\u0435 \u0437\u0430 ${Math.round(HANDSHAKE_TIMEOUT_MS / 1e3)} \u0441 \u2014 \u043F\u0440\u043E\u0431\u0443\u0435\u043C \u0441\u043D\u043E\u0432\u0430`;
+  }
+  return message;
+}
 
 // ../host/dist/terminal.js
 import { EventEmitter as EventEmitter4 } from "node:events";
 import { access as access2, constants as constants2 } from "node:fs/promises";
-import path13 from "node:path";
+import path15 from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 var SCROLLBACK_BYTES = 256 * 1024;
 var FLUSH_MS = 12;
@@ -4224,12 +4754,25 @@ var TerminalHub = class extends EventEmitter4 {
   #pty() {
     this.#module ??= import("@lydell/node-pty").then((module) => module).catch((error) => {
       this.#module = null;
-      const reason = error instanceof Error ? error.message : String(error);
-      throw new Error(`\u0422\u0435\u0440\u043C\u0438\u043D\u0430\u043B \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435: ${reason}`);
+      throw new Error(explainMissingPty(error));
     });
     return this.#module;
   }
 };
+function explainMissingPty(error) {
+  const reason = error instanceof Error ? error.message : String(error);
+  const platformPackageMissing = reason.includes("could not find the platform-specific package") || /Cannot find module '@lydell\/node-pty-/.test(reason);
+  if (!platformPackageMissing) {
+    return `\u0422\u0435\u0440\u043C\u0438\u043D\u0430\u043B \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435: ${reason}`;
+  }
+  return [
+    `\u0422\u0435\u0440\u043C\u0438\u043D\u0430\u043B \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D: \u0432 \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u043D\u043E\u043C ccv \u043D\u0435\u0442 \u0441\u0431\u043E\u0440\u043A\u0438 PTY \u043F\u043E\u0434 ${process.platform}-${process.arch}.`,
+    "\u041E\u0431\u044B\u0447\u043D\u043E \u044D\u0442\u043E \u0437\u043D\u0430\u0447\u0438\u0442, \u0447\u0442\u043E \u043F\u0430\u043A\u0435\u0442 \u0441\u0442\u0430\u0432\u0438\u043B\u0438 \u0441 \xAB--omit=optional\xBB \u043B\u0438\u0431\u043E node_modules \u043F\u0435\u0440\u0435\u0435\u0445\u0430\u043B \u0441 \u0434\u0440\u0443\u0433\u043E\u0439",
+    "\u0441\u0438\u0441\u0442\u0435\u043C\u044B. \u041B\u0435\u0447\u0438\u0442\u0441\u044F \u043F\u0435\u0440\u0435\u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043A\u043E\u0439: npm i -g @i14ks/ccv \u2014 \u0438 \u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u0435 ccv.",
+    "",
+    reason
+  ].join("\n");
+}
 function clampSize(value, min, max, fallback) {
   if (!Number.isFinite(value))
     return fallback;
@@ -4252,22 +4795,22 @@ async function defaultShell() {
     if (pwsh)
       return { file: pwsh, args: [], title: "pwsh" };
     const system = process.env.SystemRoot ?? "C:\\Windows";
-    const powershell = path13.join(system, "System32/WindowsPowerShell/v1.0/powershell.exe");
+    const powershell = path15.join(system, "System32/WindowsPowerShell/v1.0/powershell.exe");
     if (await exists2(powershell))
       return { file: powershell, args: [], title: "powershell" };
     return { file: process.env.COMSPEC ?? "cmd.exe", args: [], title: "cmd" };
   }
   const shell = process.env.SHELL;
   if (shell && await exists2(shell))
-    return { file: shell, args: [], title: path13.basename(shell) };
+    return { file: shell, args: [], title: path15.basename(shell) };
   if (await exists2("/bin/bash"))
     return { file: "/bin/bash", args: [], title: "bash" };
   return { file: "/bin/sh", args: [], title: "sh" };
 }
 async function findOnPath(name) {
-  const dirs = (process.env.PATH ?? "").split(path13.delimiter).filter(Boolean);
+  const dirs = (process.env.PATH ?? "").split(path15.delimiter).filter(Boolean);
   for (const dir of dirs) {
-    const candidate = path13.join(dir, name);
+    const candidate = path15.join(dir, name);
     if (await exists2(candidate))
       return candidate;
   }
@@ -4278,10 +4821,10 @@ function exists2(file) {
 }
 
 // ../host/dist/mcp-config.js
-import { readFile as readFile10, writeFile as writeFile7, mkdir as mkdir7 } from "node:fs/promises";
-import path14 from "node:path";
+import { readFile as readFile12, writeFile as writeFile9, mkdir as mkdir8 } from "node:fs/promises";
+import path16 from "node:path";
 var MCP_FILE = ".mcp.json";
-var LOCAL_SETTINGS2 = path14.join(".claude", "settings.local.json");
+var LOCAL_SETTINGS2 = path16.join(".claude", "settings.local.json");
 var queues = /* @__PURE__ */ new Map();
 function serialize(cwd, work) {
   const previous = queues.get(cwd) ?? Promise.resolve();
@@ -4290,7 +4833,7 @@ function serialize(cwd, work) {
   return next;
 }
 async function readProjectServers(cwd) {
-  const file = await readJson(path14.join(cwd, MCP_FILE));
+  const file = await readJson(path16.join(cwd, MCP_FILE));
   const servers = file?.mcpServers;
   if (!servers || typeof servers !== "object")
     return {};
@@ -4298,23 +4841,23 @@ async function readProjectServers(cwd) {
 }
 function addProjectServer(cwd, name, config) {
   return serialize(cwd, async () => {
-    const file = await readJson(path14.join(cwd, MCP_FILE)) ?? {};
+    const file = await readJson(path16.join(cwd, MCP_FILE)) ?? {};
     const servers = file.mcpServers ?? {};
     servers[name] = config;
     file.mcpServers = servers;
-    await writeJson(path14.join(cwd, MCP_FILE), file);
+    await writeJson(path16.join(cwd, MCP_FILE), file);
     await approve(cwd, name);
   });
 }
 function removeProjectServer(cwd, name) {
   return serialize(cwd, async () => {
-    const file = await readJson(path14.join(cwd, MCP_FILE));
+    const file = await readJson(path16.join(cwd, MCP_FILE));
     const servers = file?.mcpServers;
     if (!servers || !(name in servers))
       return false;
     delete servers[name];
-    await writeJson(path14.join(cwd, MCP_FILE), file);
-    const settingsPath = path14.join(cwd, LOCAL_SETTINGS2);
+    await writeJson(path16.join(cwd, MCP_FILE), file);
+    const settingsPath = path16.join(cwd, LOCAL_SETTINGS2);
     const settings = await readJson(settingsPath);
     const enabled = settings?.enabledMcpjsonServers;
     if (settings && Array.isArray(enabled) && enabled.includes(name)) {
@@ -4325,7 +4868,7 @@ function removeProjectServer(cwd, name) {
   });
 }
 async function approve(cwd, name) {
-  const file = path14.join(cwd, LOCAL_SETTINGS2);
+  const file = path16.join(cwd, LOCAL_SETTINGS2);
   const settings = await readJson(file) ?? {};
   const enabled = Array.isArray(settings.enabledMcpjsonServers) ? settings.enabledMcpjsonServers : [];
   if (!enabled.includes(name))
@@ -4364,21 +4907,21 @@ function describeConfig(config) {
 }
 async function readJson(file) {
   try {
-    const raw = await readFile10(file, "utf8");
+    const raw = await readFile12(file, "utf8");
     const parsed = JSON.parse(raw);
     return parsed && typeof parsed === "object" ? parsed : null;
   } catch (error) {
     if (error.code === "ENOENT")
       return null;
     if (error instanceof SyntaxError) {
-      throw new Error(`\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0440\u0430\u0437\u043E\u0431\u0440\u0430\u0442\u044C ${path14.basename(file)}: ${error.message}`);
+      throw new Error(`\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0440\u0430\u0437\u043E\u0431\u0440\u0430\u0442\u044C ${path16.basename(file)}: ${error.message}`);
     }
     throw error;
   }
 }
 async function writeJson(file, data) {
-  await mkdir7(path14.dirname(file), { recursive: true });
-  await writeFile7(file, `${JSON.stringify(data, null, 2)}
+  await mkdir8(path16.dirname(file), { recursive: true });
+  await writeFile9(file, `${JSON.stringify(data, null, 2)}
 `, "utf8");
 }
 
@@ -4414,6 +4957,16 @@ var HostServer = class {
   #auth = new AuthCli();
   #relay;
   #terminals = new TerminalHub();
+  #github;
+  /**
+   * Проекты, в которых прямо сейчас идёт сетевая операция git.
+   *
+   * Замок, а не индикатор: рабочее дерево у вкладок общее, и второй `push`
+   * поверх первого — это два процесса git на один `.git`, то есть блокировка
+   * индекса и половина операции. Ключ — `workspaceId`: параллельная работа с
+   * разными проектами при этом остаётся возможной.
+   */
+  #gitBusy = /* @__PURE__ */ new Set();
   constructor(options2) {
     this.#options = options2;
     this.#workspaces = new WorkspaceRegistry(options2.dataDir);
@@ -4422,6 +4975,7 @@ var HostServer = class {
     this.#settings = new AppSettingsStore(options2.dataDir);
     this.#finder = new ProjectFinder(this.#workspaces);
     this.#relay = new RelayLink({ dataDir: options2.dataDir, defaultUrl: options2.relayUrl });
+    this.#github = new GitHubAccount(options2.dataDir);
     this.#wireRelay();
     this.#wireTerminals();
     this.#auth.on("login", (state) => {
@@ -4436,6 +4990,7 @@ var HostServer = class {
     await this.#archive.load();
     await this.#pins.load();
     await this.#settings.load();
+    await this.#github.load();
     await warmClaudeLauncher();
     void this.#finder.warm();
     const httpServer = createServer((req, res) => this.#serveHttp(req, res));
@@ -4899,24 +5454,47 @@ var HostServer = class {
           detail: await this.#git(frame.workspaceId).show(frame.ref)
         });
         return;
-      case "git.checkout": {
-        const repo = this.#git(frame.workspaceId);
-        let ok = true;
-        let message;
-        try {
-          message = await repo.checkout(frame.target);
-        } catch (error) {
-          ok = false;
-          message = error instanceof Error ? error.message : String(error);
-        }
-        this.#broadcast({ type: "git.result", workspaceId: frame.workspaceId, ok, message });
-        this.#broadcast({
-          type: "git.state",
+      case "git.checkout":
+        await this.#gitOperation(frame.workspaceId, async (repo) => ({
+          message: await repo.checkout(frame.target)
+        }));
+        return;
+      case "git.remote":
+        await this.#gitOperation(frame.workspaceId, async (repo) => ({
+          message: await repo.setRemote(frame.url)
+        }));
+        return;
+      case "git.push":
+        await this.#gitNetwork(frame.workspaceId, "\u041E\u0442\u043F\u0440\u0430\u0432\u043B\u044F\u0435\u043C\u2026", async (repo) => ({
+          message: await repo.push(await this.#gitToken())
+        }));
+        return;
+      case "git.pull":
+        await this.#gitNetwork(frame.workspaceId, frame.merge ? "\u0417\u0430\u0431\u0438\u0440\u0430\u0435\u043C\u2026" : "\u041F\u0440\u043E\u0432\u0435\u0440\u044F\u0435\u043C remote\u2026", async (repo) => ({ message: await repo.pull(frame.merge, await this.#gitToken()) }));
+        return;
+      case "git.publish":
+        await this.#gitNetwork(frame.workspaceId, "\u041F\u0443\u0431\u043B\u0438\u043A\u0443\u0435\u043C \u043D\u0430 GitHub\u2026", (repo) => this.#publish(repo, frame));
+        return;
+      case "git.files": {
+        const { files, truncated } = await this.#git(frame.workspaceId).candidates();
+        this.#send(socket, {
+          type: "git.files",
           workspaceId: frame.workspaceId,
-          state: await repo.state()
+          files,
+          truncated
         });
         return;
       }
+      case "github.status":
+        this.#send(socket, { type: "github.status", status: await this.#github.status() });
+        return;
+      case "github.token":
+        await this.#github.setToken(frame.token);
+        this.#broadcast({ type: "github.status", status: await this.#github.status() });
+        return;
+      case "github.owners":
+        this.#send(socket, { type: "github.owners", owners: await this.#github.owners() });
+        return;
       case "fs.list":
         this.#send(socket, {
           type: "fs.dir",
@@ -5523,6 +6101,101 @@ var HostServer = class {
       throw new Error(`\u0412\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: ${workspaceId}`);
     return new GitRepo(workspace.path);
   }
+  /**
+   * Пишущая операция панели: её итог и новое состояние получают все клиенты.
+   *
+   * Broadcast, а не ответ спросившему, потому что рабочее дерево у вкладок
+   * общее: после переключения ветки или появления `origin` вторая вкладка
+   * показывала бы прежнюю картину, ничем не отличимую от настоящей.
+   *
+   * Ошибка сюда приходит текстом git и уходит текстом же — панель показывает
+   * его как есть. Своей формулировки у нас нет и быть не должно: git объясняет
+   * отказ («ваши правки будут перезаписаны», «обновлений нет») точнее.
+   */
+  async #gitOperation(workspaceId, run2) {
+    let ok = true;
+    let message = "";
+    let url2;
+    try {
+      const outcome = await run2(this.#git(workspaceId));
+      message = outcome.message;
+      url2 = outcome.url;
+    } catch (error) {
+      ok = false;
+      message = error instanceof Error ? error.message : String(error);
+    }
+    this.#broadcast({ type: "git.result", workspaceId, ok, message, ...url2 ? { url: url2 } : {} });
+    const state = await this.#git(workspaceId).state().catch(() => null);
+    if (state)
+      this.#broadcast({ type: "git.state", workspaceId, state });
+  }
+  /**
+   * То же, но операция ходит в сеть: под замком и с пометкой «идёт».
+   *
+   * Замок — не про удобство, а про целостность: два `push` на один `.git`
+   * встретятся на блокировке индекса, и второй упадёт посреди работы. Пометка
+   * рассылается всем по той же причине, по которой рассылается итог, — вкладки
+   * смотрят в один каталог.
+   */
+  async #gitNetwork(workspaceId, label, run2) {
+    if (this.#gitBusy.has(workspaceId)) {
+      this.#broadcast({
+        type: "git.result",
+        workspaceId,
+        ok: false,
+        message: "\u041E\u043F\u0435\u0440\u0430\u0446\u0438\u044F \u0441 remote \u0443\u0436\u0435 \u0438\u0434\u0451\u0442 \u2014 \u0434\u043E\u0436\u0434\u0438\u0442\u0435\u0441\u044C \u0435\u0451"
+      });
+      return;
+    }
+    this.#gitBusy.add(workspaceId);
+    this.#broadcast({ type: "git.busy", workspaceId, label });
+    try {
+      await this.#gitOperation(workspaceId, run2);
+    } finally {
+      this.#gitBusy.delete(workspaceId);
+      this.#broadcast({ type: "git.busy", workspaceId, label: "" });
+    }
+  }
+  /**
+   * Токен GitHub для команды git — или пустая строка, если аккаунта нет.
+   *
+   * Пустая строка здесь законна: push на не-GitHub remote (или на GitHub через
+   * уже настроенный ssh-ключ) должен работать ровно так же, как из терминала.
+   * Требовать учётную запись GitHub ради него значило бы сломать то, что и без
+   * нас работало.
+   */
+  async #gitToken() {
+    return await this.#github.credential().then((credential) => credential.token, () => "");
+  }
+  /**
+   * Опубликовать проект: коммит (если истории ещё нет), репозиторий, remote, push.
+   *
+   * Порядок не переставить. Коммит идёт до создания репозитория: не настроен
+   * `user.email` — git откажет, и лучше это узнать до того, как на GitHub
+   * появится пустой репозиторий, который придётся удалять руками. Репозиторий
+   * создаётся до `origin`, потому что адрес приходит вместе с ним.
+   */
+  async #publish(repo, frame) {
+    const credential = await this.#github.credential();
+    if (!(await repo.state()).available)
+      await repo.init();
+    if (frame.message)
+      await repo.commit(frame.message, frame.include, frame.ignore);
+    const created = await this.#github.createRepo({
+      owner: frame.owner,
+      name: frame.name,
+      description: frame.description,
+      private: frame.private
+    });
+    await repo.setRemote(created.cloneUrl);
+    try {
+      await repo.push(credential.token);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(`\u0420\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0439 ${created.fullName} \u0441\u043E\u0437\u0434\u0430\u043D, \u043D\u043E \u043E\u0442\u043F\u0440\u0430\u0432\u0438\u0442\u044C \u043D\u0435 \u0432\u044B\u0448\u043B\u043E: ${detail}`);
+    }
+    return { message: `\u041E\u043F\u0443\u0431\u043B\u0438\u043A\u043E\u0432\u0430\u043D\u043E: ${created.fullName}`, url: created.htmlUrl };
+  }
   // -------------------------------------------------------------------------
   // Файлы проекта
   // -------------------------------------------------------------------------
@@ -5680,8 +6353,8 @@ var HostServer = class {
       return;
     }
     const url2 = new URL(req.url ?? "/", "http://localhost");
-    const requested = path15.join(webRoot, path15.normalize(url2.pathname));
-    const target = requested.startsWith(webRoot) && existsSync3(requested) && statSync3(requested).isFile() ? requested : path15.join(webRoot, "index.html");
+    const requested = path17.join(webRoot, path17.normalize(url2.pathname));
+    const target = requested.startsWith(webRoot) && existsSync3(requested) && statSync3(requested).isFile() ? requested : path17.join(webRoot, "index.html");
     if (!existsSync3(target)) {
       res.writeHead(404).end("not found");
       return;
@@ -5707,12 +6380,12 @@ function contentType(file) {
     ".svg": "image/svg+xml",
     ".woff2": "font/woff2"
   };
-  return types[path15.extname(file)] ?? "application/octet-stream";
+  return types[path17.extname(file)] ?? "application/octet-stream";
 }
 
 // dist/ccv.js
-var HERE = path16.dirname(fileURLToPath(import.meta.url));
-var PACKAGE_ROOT = path16.resolve(HERE, "..");
+var HERE = path18.dirname(fileURLToPath(import.meta.url));
+var PACKAGE_ROOT = path18.resolve(HERE, "..");
 var USAGE = `ccv \u2014 Claude Code Visual: \u043B\u043E\u043A\u0430\u043B\u044C\u043D\u044B\u0439 \u0445\u043E\u0441\u0442 Claude Code \u0441 \u0438\u043D\u0442\u0435\u0440\u0444\u0435\u0439\u0441\u043E\u043C \u0432 \u0431\u0440\u0430\u0443\u0437\u0435\u0440\u0435.
 
 \u0418\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D\u0438\u0435:
@@ -5779,7 +6452,7 @@ var server = new HostServer({
   dataDir: defaults.dataDir,
   // UI лежит в пакете рядом с бандлом — это и есть разница между установленной
   // утилитой и запуском из репозитория, где сборка живёт в `apps/web/dist`.
-  webRoot: process.env.CCV_WEB_ROOT ?? path16.join(PACKAGE_ROOT, "web"),
+  webRoot: process.env.CCV_WEB_ROOT ?? path18.join(PACKAGE_ROOT, "web"),
   version,
   relayUrl: defaults.relayUrl
 });
@@ -5808,7 +6481,7 @@ for (const signal of ["SIGINT", "SIGTERM"]) {
 }
 async function packageVersion() {
   try {
-    const text = await readFile11(path16.join(PACKAGE_ROOT, "package.json"), "utf8");
+    const text = await readFile13(path18.join(PACKAGE_ROOT, "package.json"), "utf8");
     return JSON.parse(text).version ?? "0.0.0";
   } catch {
     return "0.0.0";