@i14ks/ccv 0.9.5 → 0.11.0

package/bundle/ccv.mjs

@@ -2,8 +2,8 @@
 
 // dist/ccv.js
 import { spawn as spawn2 } from "node:child_process";
-import { readFile as readFile13 } from "node:fs/promises";
-import path18 from "node:path";
+import { readFile as readFile14 } from "node:fs/promises";
+import path19 from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 
@@ -146,9 +146,9 @@ function envDefaults() {
 // ../host/dist/server.js
 import { createServer } from "node:http";
 import { createReadStream, existsSync as existsSync3, statSync as statSync3 } from "node:fs";
-import path17 from "node:path";
+import path18 from "node:path";
 import { homedir as homedir5 } from "node:os";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { WebSocketServer } from "ws";
 import { renameSession as renameSession2 } from "@anthropic-ai/claude-agent-sdk";
 
@@ -218,6 +218,22 @@ var AsyncQueue = class {
 import { cp, lstat, mkdir, readFile as readFile2, readdir, realpath, rename as renamePath, rm, stat, writeFile } from "node:fs/promises";
 import path3 from "node:path";
 var MAX_FILE = 4 * 1024 * 1024;
+var MAX_MEDIA = 64 * 1024 * 1024;
+var MEDIA_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+  ".avif": "image/avif",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".ogv": "video/ogg",
+  ".mov": "video/quicktime",
+  ".m4v": "video/mp4"
+};
 var SNIFF = 8192;
 var HIDDEN = /* @__PURE__ */ new Set([".git"]);
 var SEARCH_SKIP = /* @__PURE__ */ new Set([...HIDDEN, "node_modules"]);
@@ -409,6 +425,12 @@ var ProjectFiles = class {
       binary: false,
       tooLarge: false
     };
+    const mediaMime = MEDIA_MIME[path3.extname(file).toLowerCase()];
+    if (mediaMime) {
+      if (info.size > MAX_MEDIA)
+        return { ...blank, binary: true, mediaMime, mediaTooLarge: true };
+      return { ...blank, binary: true, mediaMime };
+    }
     if (info.size > MAX_FILE)
       return { ...blank, tooLarge: true };
     const buffer = await readFile2(file);
@@ -423,6 +445,28 @@ var ProjectFiles = class {
       encoding: decoded.encoding
     };
   }
+  /**
+   * Байты картинки или видео — по отдельному запросу от просмотрщика.
+   *
+   * `read` уже сказал клиенту, что это медиа (`mediaMime`) и что оно в пределах
+   * `MAX_MEDIA`, но сами байты не читал: кодировать в base64 файл, который
+   * никто не открыл (а `fs.read` шлют не только по клику — синхронизация,
+   * чужая правка на диске), значило бы жечь диск и сеть впустую. Здесь — та
+   * самая читка, по требованию.
+   */
+  async readMedia(relative) {
+    const file = await this.#resolve(relative);
+    const mime = MEDIA_MIME[path3.extname(file).toLowerCase()];
+    if (!mime)
+      throw new Error("\u0424\u0430\u0439\u043B \u043D\u0435 \u0440\u0430\u0441\u043F\u043E\u0437\u043D\u0430\u043D \u043A\u0430\u043A \u043A\u0430\u0440\u0442\u0438\u043D\u043A\u0430 \u0438\u043B\u0438 \u0432\u0438\u0434\u0435\u043E");
+    const info = await stat(file);
+    if (info.isDirectory())
+      throw new Error("\u042D\u0442\u043E \u043A\u0430\u0442\u0430\u043B\u043E\u0433, \u0430 \u043D\u0435 \u0444\u0430\u0439\u043B");
+    if (info.size > MAX_MEDIA)
+      throw new Error("\u0424\u0430\u0439\u043B \u0441\u043B\u0438\u0448\u043A\u043E\u043C \u0432\u0435\u043B\u0438\u043A \u0434\u043B\u044F \u043F\u0440\u043E\u0441\u043C\u043E\u0442\u0440\u0430");
+    const buffer = await readFile2(file);
+    return { mime, base64: buffer.toString("base64") };
+  }
   /**
    * Записать файл, если его на диске не подменили.
    *
@@ -2959,9 +3003,9 @@ function parsePatch(raw) {
       body = "";
     }
     total += body.length;
-    const path19 = status === "deleted" ? oldPath : newPath || oldPath;
+    const path20 = status === "deleted" ? oldPath : newPath || oldPath;
     files.push({
-      path: path19,
+      path: path20,
       oldPath: status === "renamed" ? oldPath : "",
       status,
       added: count(body, "+"),
@@ -2973,10 +3017,10 @@ function parsePatch(raw) {
   return { files, truncated };
 }
 function stripPrefix(value) {
-  const path19 = unquote(value.trim());
-  if (path19 === "/dev/null")
+  const path20 = unquote(value.trim());
+  if (path20 === "/dev/null")
     return "";
-  return path19.replace(/^[ab]\//, "");
+  return path20.replace(/^[ab]\//, "");
 }
 function count(body, mark) {
   let n = 0;
@@ -3508,7 +3552,7 @@ import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile4 } from
 import path9 from "node:path";
 import { listSessions as listSessions2 } from "@anthropic-ai/claude-agent-sdk";
 var WorkspaceRegistry = class {
-  #paths = [];
+  #entries = [];
   #storePath;
   constructor(dataDir) {
     this.#storePath = path9.join(dataDir, "workspaces.json");
@@ -3517,52 +3561,91 @@ var WorkspaceRegistry = class {
     try {
       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));
+      if (!Array.isArray(parsed)) {
+        this.#entries = [];
+        return;
       }
+      this.#entries = parsed.map((item) => {
+        if (typeof item === "string")
+          return { path: item };
+        if (isEntry(item))
+          return item;
+        return null;
+      }).filter((e) => e !== null && existsSync2(e.path));
     } catch {
-      this.#paths = [];
+      this.#entries = [];
     }
   }
   async #persist() {
     await mkdir3(path9.dirname(this.#storePath), { recursive: true });
-    await writeFile4(this.#storePath, JSON.stringify(this.#paths, null, 2), "utf8");
+    await writeFile4(this.#storePath, JSON.stringify(this.#entries, null, 2), "utf8");
   }
+  /** Активные проекты. */
   list() {
-    return this.#paths.map(toInfo);
+    return this.#entries.filter((e) => !e.archivedAt).map((e) => toInfo(e));
+  }
+  /** Закрытые проекты — архив, симметричный `list()`. */
+  listArchived() {
+    return this.#entries.filter((e) => e.archivedAt).map((e) => toInfo(e));
   }
   find(id) {
-    return this.list().find((w) => w.id === id);
+    const entry = this.#entries.find((e) => workspaceIdFromPath(e.path) === id);
+    return entry ? toInfo(entry) : void 0;
   }
   async open(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}`);
     }
-    if (!this.#paths.includes(absolute)) {
-      this.#paths.unshift(absolute);
+    const existing = this.#entries.find((e) => e.path === absolute);
+    if (!existing) {
+      this.#entries.unshift({ path: absolute });
+      await this.#persist();
+    } else if (existing.archivedAt) {
+      delete existing.archivedAt;
       await this.#persist();
     }
-    return toInfo(absolute);
+    return toInfo({ path: absolute });
   }
   /**
-   * Убрать проекты из списка открытых.
+   * Убрать проекты из списка открытых — в архив, а не с концами.
    *
-   * Только реестр: каталог, его файлы и транскрипты сессий остаются на месте —
-   * закрытый проект открывается обратно тем же путём и с той же историей.
-   * Пачкой, а не по одному, потому что список чистят разом и переписывать файл
-   * на каждый проект незачем.
+   * Только реестр: каталог, его файлы и транскрипты сессий остаются на месте.
+   * Запись при этом не удаляется, а помечается временем закрытия — проект
+   * возвращается в активный список через `restore()`, без повторного поиска
+   * каталога. Пачкой, а не по одному, потому что список чистят разом и
+   * переписывать файл на каждый проект незачем.
    */
   async close(ids) {
     const doomed = new Set(ids);
-    const closed = this.list().filter((w) => doomed.has(w.id));
+    const closed = [];
+    const at = Date.now();
+    for (const entry of this.#entries) {
+      if (entry.archivedAt || !doomed.has(workspaceIdFromPath(entry.path)))
+        continue;
+      entry.archivedAt = at;
+      closed.push(toInfo(entry));
+    }
     if (closed.length === 0)
       return [];
-    const gone = new Set(closed.map((w) => w.path));
-    this.#paths = this.#paths.filter((p) => !gone.has(p));
     await this.#persist();
     return closed;
   }
+  /** Вернуть проекты из архива в активный список. */
+  async restore(ids) {
+    const wanted = new Set(ids);
+    const restored = [];
+    for (const entry of this.#entries) {
+      if (!entry.archivedAt || !wanted.has(workspaceIdFromPath(entry.path)))
+        continue;
+      delete entry.archivedAt;
+      restored.push(toInfo(entry));
+    }
+    if (restored.length === 0)
+      return [];
+    await this.#persist();
+    return restored;
+  }
   /**
    * Создать каталог проекта и открыть его.
    *
@@ -3661,14 +3744,19 @@ function claudeMdStub(name) {
 function readmeStub(name) {
   return [`# ${name}`, "", "<!-- \u041E\u0434\u043D\u0430-\u0434\u0432\u0435 \u0444\u0440\u0430\u0437\u044B: \u0447\u0442\u043E \u044D\u0442\u043E \u0438 \u0437\u0430\u0447\u0435\u043C. -->", ""].join("\n");
 }
-function toInfo(absolute) {
+function toInfo(entry) {
+  const { path: absolute, archivedAt } = entry;
   return {
     id: workspaceIdFromPath(absolute),
     path: absolute,
     name: path9.basename(absolute) || absolute,
-    hasClaudeMd: existsSync2(path9.join(absolute, "CLAUDE.md"))
+    hasClaudeMd: existsSync2(path9.join(absolute, "CLAUDE.md")),
+    ...archivedAt ? { archivedAt } : {}
   };
 }
+function isEntry(value) {
+  return typeof value === "object" && value !== null && typeof value.path === "string" && (value.archivedAt === void 0 || typeof value.archivedAt === "number");
+}
 
 // ../host/dist/archive.js
 import { mkdir as mkdir4, readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
@@ -3868,38 +3956,181 @@ var SessionPins = class {
       await this.#persist();
     return changed;
   }
+  async #persist() {
+    const file = { pinned: Object.fromEntries(this.#pinned) };
+    await mkdir5(path11.dirname(this.#storePath), { recursive: true });
+    await writeFile6(this.#storePath, JSON.stringify(file, null, 2), "utf8");
+  }
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && typeof value.workspaceId === "string" && typeof value.at === "number";
+}
+
+// ../host/dist/folders.js
+import { mkdir as mkdir6, readFile as readFile9, writeFile as writeFile7 } from "node:fs/promises";
+import path12 from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+var Folders = class {
+  #workspaceFolders = /* @__PURE__ */ new Map();
+  #sessionFolders = /* @__PURE__ */ new Map();
+  #workspaceAssignments = /* @__PURE__ */ new Map();
+  #sessionAssignments = /* @__PURE__ */ new Map();
+  #storePath;
+  constructor(dataDir) {
+    this.#storePath = path12.join(dataDir, "folders.json");
+  }
+  async load() {
+    try {
+      const raw = await readFile9(this.#storePath, "utf8");
+      const parsed = JSON.parse(raw);
+      this.#workspaceFolders = new Map(Object.entries(parsed.workspaceFolders ?? {}).filter(([, r]) => isWorkspaceFolder(r)));
+      this.#sessionFolders = new Map(Object.entries(parsed.sessionFolders ?? {}).filter(([, r]) => isSessionFolder(r)));
+      this.#workspaceAssignments = new Map(Object.entries(parsed.workspaceAssignments ?? {}).filter((entry) => typeof entry[1] === "string"));
+      this.#sessionAssignments = new Map(Object.entries(parsed.sessionAssignments ?? {}).filter((entry) => typeof entry[1] === "string"));
+    } catch {
+      this.#workspaceFolders = /* @__PURE__ */ new Map();
+      this.#sessionFolders = /* @__PURE__ */ new Map();
+      this.#workspaceAssignments = /* @__PURE__ */ new Map();
+      this.#sessionAssignments = /* @__PURE__ */ new Map();
+    }
+  }
+  /** Все папки — для кадра `folder.list`. */
+  list() {
+    return {
+      workspaceFolders: [...this.#workspaceFolders].map(([id, r]) => ({ id, name: r.name })),
+      sessionFolders: [...this.#sessionFolders].map(([id, r]) => ({
+        id,
+        name: r.name,
+        workspaceId: r.workspaceId
+      }))
+    };
+  }
+  async createWorkspaceFolder(name) {
+    const id = randomUUID2();
+    this.#workspaceFolders.set(id, { name });
+    await this.#persist();
+    return id;
+  }
+  async createSessionFolder(workspaceId, name) {
+    const id = randomUUID2();
+    this.#sessionFolders.set(id, { name, workspaceId });
+    await this.#persist();
+    return id;
+  }
+  /** Переименовать папку любого вида — id уникален между обоими видами. */
+  async rename(folderId, name) {
+    const ws = this.#workspaceFolders.get(folderId);
+    if (ws) {
+      this.#workspaceFolders.set(folderId, { ...ws, name });
+      await this.#persist();
+      return true;
+    }
+    const sess = this.#sessionFolders.get(folderId);
+    if (sess) {
+      this.#sessionFolders.set(folderId, { ...sess, name });
+      await this.#persist();
+      return true;
+    }
+    return false;
+  }
   /**
-   * Забыть всё закреплённое в проекте — при его закрытии.
+   * Удалить папку. Элементы внутри неё не трогаются — только перестают на неё
+   * указывать, то есть становятся вне папок.
    *
-   * Закрытый проект не показывается нигде, и закреплённая сессия из него
-   * висела бы в панели строкой, по клику на которую открывать нечего.
+   * Возвращает, какого вида была удалённая папка (и, для папки сессий, её
+   * проект) — вызывающему это нужно, чтобы разослать обновление только туда,
+   * где папка была видна, а не всем спискам сразу.
    */
-  async forgetWorkspace(workspaceId) {
-    let changed = false;
-    for (const [id, record] of this.#pinned) {
-      if (record.workspaceId !== workspaceId)
-        continue;
-      this.#pinned.delete(id);
-      changed = true;
+  async delete(folderId) {
+    let removed = null;
+    if (this.#workspaceFolders.delete(folderId)) {
+      removed = { scope: "workspace" };
+    } else {
+      const sess = this.#sessionFolders.get(folderId);
+      if (sess && this.#sessionFolders.delete(folderId)) {
+        removed = { scope: "session", workspaceId: sess.workspaceId };
+      }
     }
-    if (changed)
+    if (!removed)
+      return null;
+    for (const [id, assigned] of this.#workspaceAssignments) {
+      if (assigned === folderId)
+        this.#workspaceAssignments.delete(id);
+    }
+    for (const [id, assigned] of this.#sessionAssignments) {
+      if (assigned === folderId)
+        this.#sessionAssignments.delete(id);
+    }
+    await this.#persist();
+    return removed;
+  }
+  /** Разложить проект по папке или вынуть из неё (`folderId: null`). */
+  async assignWorkspace(workspaceId, folderId) {
+    if (folderId === null) {
+      if (!this.#workspaceAssignments.delete(workspaceId))
+        return false;
       await this.#persist();
-    return changed;
+      return true;
+    }
+    if (!this.#workspaceFolders.has(folderId)) {
+      throw new Error(`\u041F\u0430\u043F\u043A\u0430 \u043F\u0440\u043E\u0435\u043A\u0442\u043E\u0432 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u0430: ${folderId}`);
+    }
+    this.#workspaceAssignments.set(workspaceId, folderId);
+    await this.#persist();
+    return true;
+  }
+  /**
+   * Разложить сессию по папке или вынуть из неё.
+   *
+   * Папка сессии привязана к проекту — раскладывать сессию в папку чужого
+   * проекта нельзя, иначе список одного проекта показывал бы группу, для
+   * которой в нём нет ни одной другой строки.
+   */
+  async assignSession(sessionId, workspaceId, folderId) {
+    if (folderId === null) {
+      if (!this.#sessionAssignments.delete(sessionId))
+        return false;
+      await this.#persist();
+      return true;
+    }
+    const folder = this.#sessionFolders.get(folderId);
+    if (!folder)
+      throw new Error(`\u041F\u0430\u043F\u043A\u0430 \u0441\u0435\u0441\u0441\u0438\u0439 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u0430: ${folderId}`);
+    if (folder.workspaceId !== workspaceId) {
+      throw new Error("\u041F\u0430\u043F\u043A\u0430 \u0441\u0435\u0441\u0441\u0438\u0439 \u043F\u0440\u0438\u043D\u0430\u0434\u043B\u0435\u0436\u0438\u0442 \u0434\u0440\u0443\u0433\u043E\u043C\u0443 \u043F\u0440\u043E\u0435\u043A\u0442\u0443");
+    }
+    this.#sessionAssignments.set(sessionId, folderId);
+    await this.#persist();
+    return true;
+  }
+  folderIdForWorkspace(workspaceId) {
+    return this.#workspaceAssignments.get(workspaceId);
+  }
+  folderIdForSession(sessionId) {
+    return this.#sessionAssignments.get(sessionId);
   }
   async #persist() {
-    const file = { pinned: Object.fromEntries(this.#pinned) };
-    await mkdir5(path11.dirname(this.#storePath), { recursive: true });
-    await writeFile6(this.#storePath, JSON.stringify(file, null, 2), "utf8");
+    const file = {
+      workspaceFolders: Object.fromEntries(this.#workspaceFolders),
+      sessionFolders: Object.fromEntries(this.#sessionFolders),
+      workspaceAssignments: Object.fromEntries(this.#workspaceAssignments),
+      sessionAssignments: Object.fromEntries(this.#sessionAssignments)
+    };
+    await mkdir6(path12.dirname(this.#storePath), { recursive: true });
+    await writeFile7(this.#storePath, JSON.stringify(file, null, 2), "utf8");
   }
 };
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && typeof value.workspaceId === "string" && typeof value.at === "number";
+function isWorkspaceFolder(value) {
+  return typeof value === "object" && value !== null && typeof value.name === "string";
+}
+function isSessionFolder(value) {
+  return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.workspaceId === "string";
 }
 
 // ../host/dist/app-settings.js
-import { mkdir as mkdir6, readFile as readFile9, writeFile as writeFile7 } from "node:fs/promises";
+import { mkdir as mkdir7, readFile as readFile10, writeFile as writeFile8 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import path12 from "node:path";
+import path13 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;
@@ -3934,11 +4165,11 @@ var AppSettingsStore = class {
   #settings = { ...DEFAULT_APP_SETTINGS };
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path12.join(dataDir, "app-settings.json");
+    this.#storePath = path13.join(dataDir, "app-settings.json");
   }
   async load() {
     try {
-      const raw = await readFile9(this.#storePath, "utf8");
+      const raw = await readFile10(this.#storePath, "utf8");
       this.#settings = sanitize(JSON.parse(raw), DEFAULT_APP_SETTINGS);
     } catch {
       this.#settings = { ...DEFAULT_APP_SETTINGS };
@@ -3958,8 +4189,8 @@ var AppSettingsStore = class {
   async update(patch) {
     const next = sanitize(patch, this.#settings);
     this.#settings = next;
-    await mkdir6(path12.dirname(this.#storePath), { recursive: true });
-    await writeFile7(this.#storePath, JSON.stringify(next, null, 2), "utf8");
+    await mkdir7(path13.dirname(this.#storePath), { recursive: true });
+    await writeFile8(this.#storePath, JSON.stringify(next, null, 2), "utf8");
     return this.current;
   }
 };
@@ -3997,7 +4228,7 @@ function sanitize(value, fallback) {
   return result;
 }
 function claudeHome() {
-  return path12.join(homedir3(), ".claude");
+  return path13.join(homedir3(), ".claude");
 }
 function writableRoots(mode, cwd, workspacePaths) {
   if (mode === "all")
@@ -4007,7 +4238,7 @@ function writableRoots(mode, cwd, workspacePaths) {
     return [...roots];
   for (const workspace of [cwd, ...workspacePaths]) {
     roots.add(workspace);
-    const parent = path12.dirname(workspace);
+    const parent = path13.dirname(workspace);
     if (parent !== workspace)
       roots.add(parent);
   }
@@ -4015,9 +4246,9 @@ function writableRoots(mode, cwd, workspacePaths) {
 }
 
 // ../host/dist/plugins.js
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile11 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import path13 from "node:path";
+import path14 from "node:path";
 var TIMEOUT_MS2 = 12e4;
 var SAFE_ARG = /^[A-Za-z0-9][A-Za-z0-9._@/-]*$/;
 var PluginCli = class {
@@ -4116,10 +4347,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 || path13.join(homedir4(), ".claude", "plugins", "marketplaces", market.name);
+  const root = market.installLocation || path14.join(homedir4(), ".claude", "plugins", "marketplaces", market.name);
   let manifest;
   try {
-    const text = await readFile10(path13.join(root, ".claude-plugin", "marketplace.json"), "utf8");
+    const text = await readFile11(path14.join(root, ".claude-plugin", "marketplace.json"), "utf8");
     manifest = JSON.parse(text);
   } catch {
     return [];
@@ -4360,8 +4591,8 @@ function describe4(error) {
 
 // ../host/dist/relay-link.js
 import { EventEmitter as EventEmitter3 } from "node:events";
-import { readFile as readFile11, writeFile as writeFile8, rm as rm3, mkdir as mkdir7 } from "node:fs/promises";
-import path14 from "node:path";
+import { readFile as readFile12, writeFile as writeFile9, rm as rm3, mkdir as mkdir8 } from "node:fs/promises";
+import path15 from "node:path";
 import { hostname } from "node:os";
 import WebSocket from "ws";
 
@@ -4416,7 +4647,7 @@ var RelayLink = class extends EventEmitter3 {
   #log;
   constructor(options2) {
     super();
-    this.#file = path14.join(options2.dataDir, "relay.json");
+    this.#file = path15.join(options2.dataDir, "relay.json");
     this.#defaultUrl = options2.defaultUrl.replace(/\/+$/, "");
     this.#log = options2.log ?? ((msg) => console.log(`[relay] ${msg}`));
   }
@@ -4497,7 +4728,7 @@ var RelayLink = class extends EventEmitter3 {
   }
   async #read() {
     try {
-      const raw = await readFile11(this.#file, "utf8");
+      const raw = await readFile12(this.#file, "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed !== "object" || parsed === null)
         return null;
@@ -4510,8 +4741,8 @@ var RelayLink = class extends EventEmitter3 {
     }
   }
   async #write(credentials) {
-    await mkdir7(path14.dirname(this.#file), { recursive: true });
-    await writeFile8(this.#file, `${JSON.stringify(credentials, null, 2)}
+    await mkdir8(path15.dirname(this.#file), { recursive: true });
+    await writeFile9(this.#file, `${JSON.stringify(credentials, null, 2)}
 `, {
       encoding: "utf8",
       mode: 384
@@ -4768,8 +4999,8 @@ function humanize(error) {
 // ../host/dist/terminal.js
 import { EventEmitter as EventEmitter4 } from "node:events";
 import { access as access2, constants as constants2 } from "node:fs/promises";
-import path15 from "node:path";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import path16 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
 var SCROLLBACK_BYTES = 256 * 1024;
 var FLUSH_MS = 12;
 var MAX_TERMINALS = 24;
@@ -4806,7 +5037,7 @@ var TerminalHub = class extends EventEmitter4 {
       env: environment()
     });
     const info = {
-      id: randomUUID2(),
+      id: randomUUID3(),
       workspaceId: options2.workspaceId,
       title: shell.title,
       shell: shell.file,
@@ -4938,22 +5169,22 @@ async function defaultShell() {
     if (pwsh)
       return { file: pwsh, args: [], title: "pwsh" };
     const system = process.env.SystemRoot ?? "C:\\Windows";
-    const powershell = path15.join(system, "System32/WindowsPowerShell/v1.0/powershell.exe");
+    const powershell = path16.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: path15.basename(shell) };
+    return { file: shell, args: [], title: path16.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(path15.delimiter).filter(Boolean);
+  const dirs = (process.env.PATH ?? "").split(path16.delimiter).filter(Boolean);
   for (const dir of dirs) {
-    const candidate = path15.join(dir, name);
+    const candidate = path16.join(dir, name);
     if (await exists2(candidate))
       return candidate;
   }
@@ -4964,10 +5195,10 @@ function exists2(file) {
 }
 
 // ../host/dist/mcp-config.js
-import { readFile as readFile12, writeFile as writeFile9, mkdir as mkdir8 } from "node:fs/promises";
-import path16 from "node:path";
+import { readFile as readFile13, writeFile as writeFile10, mkdir as mkdir9 } from "node:fs/promises";
+import path17 from "node:path";
 var MCP_FILE = ".mcp.json";
-var LOCAL_SETTINGS2 = path16.join(".claude", "settings.local.json");
+var LOCAL_SETTINGS2 = path17.join(".claude", "settings.local.json");
 var queues = /* @__PURE__ */ new Map();
 function serialize(cwd, work) {
   const previous = queues.get(cwd) ?? Promise.resolve();
@@ -4976,7 +5207,7 @@ function serialize(cwd, work) {
   return next;
 }
 async function readProjectServers(cwd) {
-  const file = await readJson(path16.join(cwd, MCP_FILE));
+  const file = await readJson(path17.join(cwd, MCP_FILE));
   const servers = file?.mcpServers;
   if (!servers || typeof servers !== "object")
     return {};
@@ -4984,23 +5215,23 @@ async function readProjectServers(cwd) {
 }
 function addProjectServer(cwd, name, config) {
   return serialize(cwd, async () => {
-    const file = await readJson(path16.join(cwd, MCP_FILE)) ?? {};
+    const file = await readJson(path17.join(cwd, MCP_FILE)) ?? {};
     const servers = file.mcpServers ?? {};
     servers[name] = config;
     file.mcpServers = servers;
-    await writeJson(path16.join(cwd, MCP_FILE), file);
+    await writeJson(path17.join(cwd, MCP_FILE), file);
     await approve(cwd, name);
   });
 }
 function removeProjectServer(cwd, name) {
   return serialize(cwd, async () => {
-    const file = await readJson(path16.join(cwd, MCP_FILE));
+    const file = await readJson(path17.join(cwd, MCP_FILE));
     const servers = file?.mcpServers;
     if (!servers || !(name in servers))
       return false;
     delete servers[name];
-    await writeJson(path16.join(cwd, MCP_FILE), file);
-    const settingsPath = path16.join(cwd, LOCAL_SETTINGS2);
+    await writeJson(path17.join(cwd, MCP_FILE), file);
+    const settingsPath = path17.join(cwd, LOCAL_SETTINGS2);
     const settings = await readJson(settingsPath);
     const enabled = settings?.enabledMcpjsonServers;
     if (settings && Array.isArray(enabled) && enabled.includes(name)) {
@@ -5011,7 +5242,7 @@ function removeProjectServer(cwd, name) {
   });
 }
 async function approve(cwd, name) {
-  const file = path16.join(cwd, LOCAL_SETTINGS2);
+  const file = path17.join(cwd, LOCAL_SETTINGS2);
   const settings = await readJson(file) ?? {};
   const enabled = Array.isArray(settings.enabledMcpjsonServers) ? settings.enabledMcpjsonServers : [];
   if (!enabled.includes(name))
@@ -5050,21 +5281,21 @@ function describeConfig(config) {
 }
 async function readJson(file) {
   try {
-    const raw = await readFile12(file, "utf8");
+    const raw = await readFile13(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 ${path16.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 ${path17.basename(file)}: ${error.message}`);
     }
     throw error;
   }
 }
 async function writeJson(file, data) {
-  await mkdir8(path16.dirname(file), { recursive: true });
-  await writeFile9(file, `${JSON.stringify(data, null, 2)}
+  await mkdir9(path17.dirname(file), { recursive: true });
+  await writeFile10(file, `${JSON.stringify(data, null, 2)}
 `, "utf8");
 }
 
@@ -5078,6 +5309,7 @@ var HostServer = class {
   #workspaces;
   #archive;
   #pins;
+  #folders;
   #settings;
   #finder;
   #sessions = /* @__PURE__ */ new Map();
@@ -5095,7 +5327,7 @@ var HostServer = class {
   #clients = /* @__PURE__ */ new Set();
   /** Удалённые вкладки по их id в relay — чтобы адресовать ответ именно той. */
   #remotes = /* @__PURE__ */ new Map();
-  #hostId = randomUUID3();
+  #hostId = randomUUID4();
   #plugins = new PluginCli();
   #auth = new AuthCli();
   #relay;
@@ -5115,6 +5347,7 @@ var HostServer = class {
     this.#workspaces = new WorkspaceRegistry(options2.dataDir);
     this.#archive = new SessionArchive(options2.dataDir);
     this.#pins = new SessionPins(options2.dataDir);
+    this.#folders = new Folders(options2.dataDir);
     this.#settings = new AppSettingsStore(options2.dataDir);
     this.#finder = new ProjectFinder(this.#workspaces);
     this.#relay = new RelayLink({ dataDir: options2.dataDir, defaultUrl: options2.relayUrl });
@@ -5132,6 +5365,7 @@ var HostServer = class {
     await this.#workspaces.load();
     await this.#archive.load();
     await this.#pins.load();
+    await this.#folders.load();
     await this.#settings.load();
     await this.#github.load();
     await warmClaudeLauncher();
@@ -5281,6 +5515,27 @@ var HostServer = class {
         client.send(frame);
     }
   }
+  /** Активные и архивные проекты разом, с папкой каждого — для `workspace.list`. */
+  #workspaceLists() {
+    const withFolder = (w) => {
+      const folderId = this.#folders.folderIdForWorkspace(w.id);
+      return folderId ? { ...w, folderId } : w;
+    };
+    return {
+      workspaces: this.#workspaces.list().map(withFolder),
+      archived: this.#workspaces.listArchived().map(withFolder)
+    };
+  }
+  #broadcastWorkspaces() {
+    this.#broadcast({ type: "workspace.list", ...this.#workspaceLists() });
+  }
+  #sendFolders(client) {
+    const frame = { type: "folder.list", ...this.#folders.list() };
+    if (client)
+      this.#send(client, frame);
+    else
+      this.#broadcast(frame);
+  }
   async #handleFrame(socket, frame) {
     switch (frame.type) {
       case "hello":
@@ -5291,10 +5546,8 @@ var HostServer = class {
           hostVersion: this.#options.version,
           platform: process.platform
         });
-        this.#send(socket, {
-          type: "workspace.list",
-          workspaces: this.#workspaces.list()
-        });
+        this.#send(socket, { type: "workspace.list", ...this.#workspaceLists() });
+        this.#sendFolders(socket);
         this.#auth.status().then((status) => this.#send(socket, { type: "auth.status", status })).catch(() => void 0);
         this.#send(socket, { type: "relay.state", state: this.#relay.state });
         return;
@@ -5302,17 +5555,11 @@ var HostServer = class {
         this.#send(socket, { type: "pong", nonce: frame.nonce });
         return;
       case "workspace.list":
-        this.#send(socket, {
-          type: "workspace.list",
-          workspaces: this.#workspaces.list()
-        });
+        this.#send(socket, { type: "workspace.list", ...this.#workspaceLists() });
         return;
       case "workspace.open":
         await this.#workspaces.open(frame.path);
-        this.#broadcast({
-          type: "workspace.list",
-          workspaces: this.#workspaces.list()
-        });
+        this.#broadcastWorkspaces();
         await this.#closeFinder();
         return;
       case "workspace.close": {
@@ -5325,17 +5572,14 @@ var HostServer = class {
             continue;
           await this.#dropSession(session.id, "workspace closed");
         }
-        let unpinned = false;
-        for (const id of gone) {
-          if (await this.#pins.forgetWorkspace(id))
-            unpinned = true;
-        }
-        this.#broadcast({
-          type: "workspace.list",
-          workspaces: this.#workspaces.list()
-        });
-        if (unpinned)
-          await this.#sendPinned();
+        this.#broadcastWorkspaces();
+        return;
+      }
+      case "workspace.restore": {
+        const restored = await this.#workspaces.restore(frame.workspaceIds);
+        if (restored.length === 0)
+          return;
+        this.#broadcastWorkspaces();
         return;
       }
       case "workspace.find": {
@@ -5357,10 +5601,7 @@ var HostServer = class {
         return;
       case "workspace.create": {
         const { workspace, warnings } = await this.#workspaces.create(frame.parent, frame.name, frame.init);
-        this.#broadcast({
-          type: "workspace.list",
-          workspaces: this.#workspaces.list()
-        });
+        this.#broadcastWorkspaces();
         this.#send(socket, { type: "workspace.created", workspace, warnings });
         await this.#closeFinder();
         return;
@@ -5422,6 +5663,42 @@ var HostServer = class {
       case "session.pins":
         await this.#sendPinned();
         return;
+      case "folder.create": {
+        if (frame.scope === "session") {
+          if (!frame.workspaceId)
+            throw new Error("\u0414\u043B\u044F \u043F\u0430\u043F\u043A\u0438 \u0441\u0435\u0441\u0441\u0438\u0439 \u043D\u0443\u0436\u0435\u043D workspaceId");
+          await this.#folders.createSessionFolder(frame.workspaceId, frame.name);
+        } else {
+          await this.#folders.createWorkspaceFolder(frame.name);
+        }
+        this.#sendFolders();
+        return;
+      }
+      case "folder.rename":
+        if (await this.#folders.rename(frame.folderId, frame.name))
+          this.#sendFolders();
+        return;
+      case "folder.delete": {
+        const removed = await this.#folders.delete(frame.folderId);
+        if (!removed)
+          return;
+        this.#sendFolders();
+        if (removed.scope === "workspace")
+          this.#broadcastWorkspaces();
+        else
+          await this.#sendSessionList(removed.workspaceId);
+        return;
+      }
+      case "folder.assign": {
+        if (frame.workspaceId) {
+          await this.#folders.assignSession(frame.itemId, frame.workspaceId, frame.folderId);
+          await this.#sendSessionList(frame.workspaceId);
+        } else {
+          await this.#folders.assignWorkspace(frame.itemId, frame.folderId);
+          this.#broadcastWorkspaces();
+        }
+        return;
+      }
       case "session.rename":
         await this.#renameSession(frame.sessionId, frame.title, frame.workspaceId);
         return;
@@ -5679,6 +5956,26 @@ var HostServer = class {
           file: await this.#files(frame.workspaceId).read(frame.path)
         });
         return;
+      case "fs.readMedia": {
+        try {
+          const { mime, base64 } = await this.#files(frame.workspaceId).readMedia(frame.path);
+          this.#send(socket, {
+            type: "fs.media",
+            workspaceId: frame.workspaceId,
+            path: normalize(frame.path),
+            mime,
+            base64
+          });
+        } catch (error) {
+          this.#send(socket, {
+            type: "fs.mediaFailed",
+            workspaceId: frame.workspaceId,
+            path: normalize(frame.path),
+            message: error instanceof Error ? error.message : String(error)
+          });
+        }
+        return;
+      }
       case "fs.write": {
         const files = this.#files(frame.workspaceId);
         let saved;
@@ -6468,7 +6765,12 @@ var HostServer = class {
     const archived = [];
     for (const base of [...live, ...historical].sort((a, b) => b.updatedAt - a.updatedAt)) {
       const pin = this.#pins.find(base.claudeSessionId ?? base.id);
-      const summary = pin ? { ...base, pinned: true, pinnedAt: pin.at } : base;
+      const folderId = this.#folders.folderIdForSession(base.claudeSessionId ?? base.id);
+      const summary = {
+        ...base,
+        ...pin ? { pinned: true, pinnedAt: pin.at } : {},
+        ...folderId ? { folderId } : {}
+      };
       const record = this.#archive.find(summary.claudeSessionId ?? summary.id);
       if (!record) {
         sessions.push(summary);
@@ -6506,8 +6808,8 @@ var HostServer = class {
       return;
     }
     const url2 = new URL(req.url ?? "/", "http://localhost");
-    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");
+    const requested = path18.join(webRoot, path18.normalize(url2.pathname));
+    const target = requested.startsWith(webRoot) && existsSync3(requested) && statSync3(requested).isFile() ? requested : path18.join(webRoot, "index.html");
     if (!existsSync3(target)) {
       res.writeHead(404).end("not found");
       return;
@@ -6533,12 +6835,12 @@ function contentType(file) {
     ".svg": "image/svg+xml",
     ".woff2": "font/woff2"
   };
-  return types[path17.extname(file)] ?? "application/octet-stream";
+  return types[path18.extname(file)] ?? "application/octet-stream";
 }
 
 // dist/ccv.js
-var HERE = path18.dirname(fileURLToPath(import.meta.url));
-var PACKAGE_ROOT = path18.resolve(HERE, "..");
+var HERE = path19.dirname(fileURLToPath(import.meta.url));
+var PACKAGE_ROOT = path19.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:
@@ -6605,7 +6907,7 @@ var server = new HostServer({
   dataDir: defaults.dataDir,
   // UI лежит в пакете рядом с бандлом — это и есть разница между установленной
   // утилитой и запуском из репозитория, где сборка живёт в `apps/web/dist`.
-  webRoot: process.env.CCV_WEB_ROOT ?? path18.join(PACKAGE_ROOT, "web"),
+  webRoot: process.env.CCV_WEB_ROOT ?? path19.join(PACKAGE_ROOT, "web"),
   version,
   relayUrl: defaults.relayUrl
 });
@@ -6634,7 +6936,7 @@ for (const signal of ["SIGINT", "SIGTERM"]) {
 }
 async function packageVersion() {
   try {
-    const text = await readFile13(path18.join(PACKAGE_ROOT, "package.json"), "utf8");
+    const text = await readFile14(path19.join(PACKAGE_ROOT, "package.json"), "utf8");
     return JSON.parse(text).version ?? "0.0.0";
   } catch {
     return "0.0.0";