claude-desktop-merge 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 sebryu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,188 @@
+# claude-desktop-merge
+
+Merge and sync **Claude desktop app** sessions across accounts — macOS, zero dependencies, dry-run by default.
+
+> When you log into a different Claude account, the desktop app shows an empty session list. Your conversations aren't gone — the app just scopes its session index per account. This tool reconciles that: it merges every account's session list into one canonical location and (optionally) symlinks the others to it so they stay in sync.
+
+Not affiliated with Anthropic. It only reorganizes local files the desktop app already wrote; it never uploads anything and never touches your transcripts.
+
+## Demo
+
+<p align="center">
+  <img src="docs/showcase.svg" alt="claude-desktop-merge dry run: discover every account, print a plan, change nothing" width="680">
+</p>
+
+A **dry run** discovers every account, prints exactly what it would copy, and changes nothing until you add `--apply`. There's a full walkthrough page at [`docs/index.html`](docs/index.html) — open it locally, or serve the `docs/` folder with GitHub Pages.
+
+<details>
+<summary>Same run, as plain text</summary>
+
+```text
+$ npx claude-desktop-merge
+claude-desktop-merge (macOS)
+BASE: ~/Library/Application Support/Claude
+Active account: be60c637
+
+Discovered locations:
+  1) be60c637/04127aae   (102 sessions)  [ACTIVE]
+       · Refactor auth middleware
+       · Wire up billing webhooks
+  2) d8755814/f9c0ba6b   (47 sessions)
+       · Fix flaky e2e test
+       · Draft launch checklist
+
+Choose CANONICAL location (number): 1
+Choose SOURCE location(s) — 'a' for all others: a
+1) MERGE only  2) MERGE then LINK — choose [1/2]: 1
+
+PLAN
+  Canonical: be60c637/04127aae
+  Source d8755814/f9c0ba6b
+    [claude-code-sessions] copy 47 files, 0 dirs; 0 conflicts
+    [agent-mode]           copy 41 files, 6 dirs; 2 conflicts (kept canonical)
+
+  Totals: 88 file(s) + 6 dir(s) to copy, 2 kept, 3 space(s) added
+
+DRY RUN — no filesystem changes were made.
+Re-run with --apply to execute the plan above.
+```
+
+<sub>Account/org IDs are shortened here for readability; the tool prints the full UUIDs.</sub>
+
+</details>
+
+## Install (macOS)
+
+Pick whichever you like — all three give you a `claude-desktop-merge` command and **none of them require you to install anything first**.
+
+**1. One-line installer** — the simplest. Downloads the tool and puts it on your PATH; if you don't already have a runtime it installs [Bun](https://bun.sh) for you.
+
+```sh
+curl -fsSL https://raw.githubusercontent.com/sebryu/claude-desktop-merge/main/install.sh | bash
+```
+
+**2. npm** — if you already have Node:
+
+```sh
+npx claude-desktop-merge            # run once, nothing installed
+# or install the command globally:
+npm install -g claude-desktop-merge
+```
+
+**3. From source** — if you want to read or hack on it:
+
+```sh
+git clone https://github.com/sebryu/claude-desktop-merge.git
+cd claude-desktop-merge
+bun claude-desktop-merge.ts         # or: node claude-desktop-merge.ts   (Node >= 23.6)
+```
+
+Then run it — it's a **dry run** that changes nothing:
+
+```sh
+claude-desktop-merge                # discover accounts, print a plan
+claude-desktop-merge --revert       # preview undoing a previous --link
+```
+
+That's the whole tool — **one command**; everything else is a flag, and **nothing changes until you add `--apply`.** See [Usage](#usage) for the flag table.
+
+> **Uninstall.** Installer: `rm ~/.local/bin/claude-desktop-merge && rm -rf ~/.local/share/claude-desktop-merge`. npm: `npm uninstall -g claude-desktop-merge`.
+
+---
+
+## The storage model (why this is safe)
+
+The macOS desktop app keeps two different things in two different places:
+
+| | Location | Account-scoped? |
+|---|---|---|
+| **Transcripts** (the actual conversation) | `~/.claude/projects/<encoded-cwd>/<id>.jsonl` | **No** — global, shared with the CLI |
+| **Session index** (pointer files: title, model, cwd, archive state) | `~/Library/Application Support/Claude/{claude-code-sessions,local-agent-mode-sessions}/<accountUuid>/<orgUuid>/local_<id>.json` | **Yes** — one folder per account/org |
+
+Because the transcripts are global, switching accounts never loses a conversation — the desktop UI just stops *listing* it, since it reads a different `<account>/<org>` folder. This tool only reorganizes the small pointer files. **It never reads, writes, moves, or deletes anything under `~/.claude` or any `.jsonl`.**
+
+## How it works — canonical merge, then link
+
+1. **MERGE** (non-destructive) — pick one **canonical** `<account>/<org>`. Copy the pointer files that exist only in other accounts *into* canonical. Union `spaces.json` by id. Archive flags ride along inside each pointer file.
+2. **LINK** (opt-in, `--link`) — back up each other account's folder to `*.bak-<timestamp>` and replace it with a symlink to canonical, so all accounts share one live set going forward.
+
+The one rule that keeps it consistent: **copy _into_ canonical; symlink every other account _at_ canonical.** Never copy into a folder you then link away.
+
+Pinned/grouped sessions live in a single global LevelDB keyed by session id, so they follow the merged sessions automatically — the tool reads it read-only to report which pins carry over, and never edits it.
+
+## Usage
+
+```
+claude-desktop-merge [flags]
+```
+
+Everything is a **dry run** until you pass `--apply`.
+
+```sh
+# 1. See what's there (interactive picker + plan, no changes)
+claude-desktop-merge
+
+# 2. Merge one account's sessions into another
+claude-desktop-merge --canonical=<acct>/<org> --sources=<acct>/<org> --apply
+
+# 3. Keep them in sync: quit the desktop app first, then link
+claude-desktop-merge --canonical=<acct>/<org> --sources=<acct>/<org> --link --apply
+
+# 4. Changed your mind? Undo the linking (quit the desktop app first)
+claude-desktop-merge --revert            # dry-run: preview what gets restored
+claude-desktop-merge --revert --apply    # restore the pre-symlink backups
+```
+
+| Flag | Meaning |
+|---|---|
+| `--canonical=<a>/<o>` | Target location that receives the merged sessions |
+| `--sources=<a>/<o>[,...]` | Source locations to merge from |
+| `--all-others` | Use every non-canonical location as a source |
+| `--link` | Also do Step B: back up each source folder and symlink it to canonical |
+| `--revert` | Undo a previous `--link`: restore each `*.bak-<ts>` backup over its symlink |
+| `--apply` | Execute. Without it, the tool is a dry run |
+| `--yes`, `-y` | Skip the confirmation prompt on `--apply` |
+| `--log-file=<path>` | Write the run log here (default: `logs/desktop-merge-<ts>.log`) |
+| `--no-log` | Disable file logging for this run |
+| `--help`, `-h` | Show help |
+
+## Reverting a link
+
+`--link` is fully reversible. It leaves a `*.bak-<timestamp>` backup next to every folder it turns into a symlink, and `--revert` walks those backups to put things back:
+
+```sh
+claude-desktop-merge --revert          # dry-run: show which symlinks would be restored
+claude-desktop-merge --revert --apply  # drop each symlink, move the newest backup back
+```
+
+- It only ever removes a **symlink**. If a real directory has reappeared at the original path (e.g. the desktop app recreated it), that's reported as a conflict and left untouched — nothing is overwritten.
+- When several backups exist for the same folder, the **newest** is restored and older ones are left in place.
+- Quit the desktop app first, same as with `--link`.
+
+The merged copies inside canonical are *not* touched by revert — reverting only undoes the symlinking (Step B), returning each account to its own independent folder.
+
+## Logging
+
+Every run is mirrored to a log file (ANSI colors stripped) so you have a record of exactly what was planned and applied:
+
+```
+logs/desktop-merge-<timestamp>.log     # default, next to the script
+```
+
+- `--log-file=<path>` writes the log somewhere else.
+- `--no-log` turns file logging off for that run.
+
+The `logs/` folder is git-ignored.
+
+## Safety
+
+- **Dry-run by default** — nothing changes without `--apply`.
+- **Never overwrites** canonical files; conflicts are reported and canonical is kept.
+- **Backs up** every folder before replacing it with a symlink (`*.bak-<timestamp>`), and `--revert` restores those backups.
+- **Read-only** on LevelDB; **never touches** `~/.claude` transcripts.
+- **Every run is logged** to a file for an audit trail.
+- Quit the desktop app before `--link` or `--revert` so it doesn't recreate the folders mid-operation.
+
+## License
+
+MIT

package/dist/claude-desktop-merge.mjs

@@ -0,0 +1,961 @@
+#!/usr/bin/env node
+
+// claude-desktop-merge.ts
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import readline from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+var useColor = process.env.NO_COLOR == null && stdout.isTTY === true;
+var paint = (code) => (s) => useColor ? `\x1B[${code}m${s}\x1B[0m` : s;
+var c = {
+  bold: paint("1"),
+  dim: paint("2"),
+  red: paint("31"),
+  green: paint("32"),
+  yellow: paint("33"),
+  blue: paint("34"),
+  cyan: paint("36")
+};
+var ANSI_RE = /\x1b\[[0-9;]*m/g;
+var logFd = null;
+var logFilePath = null;
+function scriptDir() {
+  const meta = import.meta;
+  if (typeof meta.dir === "string")
+    return meta.dir;
+  return path.dirname(new URL(meta.url).pathname);
+}
+function writeLogRaw(line) {
+  if (logFd == null)
+    return;
+  try {
+    fs.writeSync(logFd, line);
+  } catch {}
+}
+function initLogging(explicitPath, argv) {
+  try {
+    const target = explicitPath ? path.resolve(explicitPath) : path.join(scriptDir(), "logs", `desktop-merge-${timestamp()}.log`);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    logFd = fs.openSync(target, "a");
+    logFilePath = target;
+    const patch = (orig) => function(chunk, ...rest) {
+      try {
+        if (logFd != null) {
+          const s = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+          fs.writeSync(logFd, s.replace(ANSI_RE, ""));
+        }
+      } catch {}
+      return orig(chunk, ...rest);
+    };
+    process.stdout.write = patch(process.stdout.write.bind(process.stdout));
+    process.stderr.write = patch(process.stderr.write.bind(process.stderr));
+    writeLogRaw(`
+===== claude-desktop-merge @ ${new Date().toISOString()} =====
+`);
+    writeLogRaw(`argv: ${argv.length ? argv.join(" ") : "(none)"}
+
+`);
+  } catch (err) {
+    process.stderr.write(c.yellow(`warning: file logging disabled (${err.message})
+`));
+    logFd = null;
+    logFilePath = null;
+  }
+}
+function closeLogging() {
+  if (logFd == null)
+    return;
+  writeLogRaw(`
+===== end @ ${new Date().toISOString()} =====
+`);
+  try {
+    fs.closeSync(logFd);
+  } catch {}
+  logFd = null;
+}
+var TREES = ["claude-code-sessions", "local-agent-mode-sessions"];
+var SESSION_FILE_RE = /^local_.*\.json$/;
+function isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function exists(p) {
+  try {
+    fs.lstatSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isSymlink(p) {
+  try {
+    return fs.lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function listDirs(dir) {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory() || d.isSymbolicLink() && isDir(path.join(dir, d.name))).map((d) => d.name).sort();
+  } catch {
+    return [];
+  }
+}
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function fail(msg) {
+  process.stderr.write(c.red(`error: ${msg}`) + `
+`);
+  process.exit(1);
+}
+function parseArgs(argv) {
+  const a = { apply: false, link: false, revert: false, yes: false, help: false, allOthers: false, noLog: false };
+  for (const raw of argv) {
+    if (raw === "--apply")
+      a.apply = true;
+    else if (raw === "--link")
+      a.link = true;
+    else if (raw === "--revert")
+      a.revert = true;
+    else if (raw === "--yes" || raw === "-y")
+      a.yes = true;
+    else if (raw === "--help" || raw === "-h")
+      a.help = true;
+    else if (raw === "--all-others")
+      a.allOthers = true;
+    else if (raw === "--no-log")
+      a.noLog = true;
+    else if (raw.startsWith("--log-file="))
+      a.logFile = raw.slice("--log-file=".length).trim();
+    else if (raw.startsWith("--canonical="))
+      a.canonical = raw.slice("--canonical=".length).trim();
+    else if (raw.startsWith("--sources=")) {
+      a.sources = raw.slice("--sources=".length).split(",").map((s) => s.trim()).filter(Boolean);
+    } else
+      fail(`unknown argument: ${raw} (use --help)`);
+  }
+  return a;
+}
+function printHelp() {
+  const b = c.bold;
+  process.stdout.write(`${b("claude-desktop-merge")} — merge Claude desktop session metadata across accounts (macOS only)
+
+${b("USAGE")}
+  claude-desktop-merge [flags]
+
+${b("FLAGS")}
+  --canonical=<acct>/<org>   Target location that receives the merged sessions.
+  --sources=<a>/<o>[,...]    One or more source locations to merge FROM.
+  --all-others               Use every non-canonical location as a source.
+  --link                     Also do Step B: back up each source org dir and symlink it to canonical.
+  --revert                   Undo a previous --link: restore each *.bak-<ts> backup over its symlink.
+  --apply                    Execute changes. Without this flag the tool is a DRY RUN (nothing changes).
+  --yes, -y                  Skip the confirmation prompt on --apply.
+  --log-file=<path>          Write the run log here (default: <script-dir>/logs/desktop-merge-<ts>.log).
+  --no-log                   Disable file logging for this run.
+  --help, -h                 Show this help.
+
+${b("CONCEPT")}
+  A "location" is an <account>/<org> pair under the two session trees. MERGE (non-destructive) copies
+  pointer files/dirs from sources INTO canonical across both trees and unions spaces.json by id
+  (canonical wins). LINK (destructive, opt-in) replaces each source org dir with a symlink to canonical.
+  REVERT undoes LINK by restoring the *.bak-<ts> backups it left behind. Every run is logged to a file.
+
+${b("EXAMPLES")}
+  claude-desktop-merge                                              # interactive, dry-run
+  claude-desktop-merge --canonical=A/O --sources=B/O                # dry-run plan
+  claude-desktop-merge --canonical=A/O --all-others --apply         # apply MERGE only
+  claude-desktop-merge --canonical=A/O --all-others --link --apply  # apply MERGE + LINK
+  claude-desktop-merge --revert                                     # dry-run: preview the undo
+  claude-desktop-merge --revert --apply                             # restore pre-symlink backups
+`);
+}
+function discoverLocations(base) {
+  const map = new Map;
+  for (const tree of TREES) {
+    const treeDir = path.join(base, tree);
+    if (!isDir(treeDir))
+      continue;
+    for (const account of listDirs(treeDir)) {
+      for (const org of listDirs(path.join(treeDir, account))) {
+        const key = `${account}/${org}`;
+        if (!map.has(key))
+          map.set(key, { account, org, key });
+      }
+    }
+  }
+  return [...map.values()].sort((x, y) => x.key.localeCompare(y.key));
+}
+function orgDir(base, tree, loc) {
+  return path.join(base, tree, loc.account, loc.org);
+}
+function readOrgEntries(dir) {
+  const out = { files: [], dirs: [] };
+  let dirents;
+  try {
+    dirents = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const d of dirents) {
+    if (d.name === "spaces.json")
+      continue;
+    const full = path.join(dir, d.name);
+    const entryIsDir = d.isDirectory() || d.isSymbolicLink() && isDir(full);
+    if (entryIsDir)
+      out.dirs.push(d.name);
+    else if (d.isFile() && SESSION_FILE_RE.test(d.name))
+      out.files.push(d.name);
+  }
+  out.files.sort();
+  out.dirs.sort();
+  return out;
+}
+function summarizeLocation(base, loc) {
+  const byId = new Map;
+  for (const tree of TREES) {
+    const dir = orgDir(base, tree, loc);
+    const { files } = readOrgEntries(dir);
+    for (const name of files) {
+      const id = name.replace(/\.json$/, "");
+      if (byId.has(id))
+        continue;
+      const idx = readJson(path.join(dir, name));
+      const title = idx && typeof idx.title === "string" && idx.title || id;
+      const lastActivityAt = idx && Number(idx.lastActivityAt) || 0;
+      byId.set(id, { title, lastActivityAt });
+    }
+  }
+  const recentTitles = [...byId.values()].sort((a, b) => b.lastActivityAt - a.lastActivityAt).slice(0, 3).map((s) => s.title);
+  return { total: byId.size, recentTitles };
+}
+function readSpaces(spacesPath) {
+  const data = readJson(spacesPath);
+  if (data && Array.isArray(data.spaces))
+    return data.spaces;
+  return [];
+}
+function buildSourcePlan(base, canon, source) {
+  const plan = { source, copies: [], conflicts: [], identical: 0, spacesAdded: [] };
+  for (const tree of TREES) {
+    const srcDir = orgDir(base, tree, source);
+    const canonDir = orgDir(base, tree, canon);
+    if (!isDir(srcDir))
+      continue;
+    const srcEntries = readOrgEntries(srcDir);
+    const candidates = [
+      ...srcEntries.files.map((name) => ({ name, kind: "file" })),
+      ...srcEntries.dirs.map((name) => ({ name, kind: "dir" }))
+    ];
+    for (const { name, kind } of candidates) {
+      const src = path.join(srcDir, name);
+      const dest = path.join(canonDir, name);
+      if (!exists(dest)) {
+        plan.copies.push({ tree, name, kind, src, dest });
+        continue;
+      }
+      if (kind === "dir") {
+        plan.conflicts.push({ tree, name, kind, reason: "dir-exists" });
+        continue;
+      }
+      let differs = true;
+      try {
+        differs = Buffer.compare(fs.readFileSync(src), fs.readFileSync(dest)) !== 0;
+      } catch {
+        differs = true;
+      }
+      if (differs)
+        plan.conflicts.push({ tree, name, kind, reason: "differs" });
+      else
+        plan.identical += 1;
+    }
+  }
+  return plan;
+}
+function collectSessionIds(entries) {
+  return [
+    ...entries.files.map((n) => n.replace(/\.json$/, "")),
+    ...entries.dirs.filter((n) => n.startsWith("local_"))
+  ];
+}
+function buildPlan(base, canon, sources, linkMode) {
+  const sessionIds = new Set;
+  const spaceIds = new Set;
+  const sourcePlans = sources.map((s) => buildSourcePlan(base, canon, s));
+  for (const tree of TREES) {
+    for (const id of collectSessionIds(readOrgEntries(orgDir(base, tree, canon))))
+      sessionIds.add(id);
+    for (const s of sources)
+      for (const id of collectSessionIds(readOrgEntries(orgDir(base, tree, s))))
+        sessionIds.add(id);
+  }
+  const agentTree = "local-agent-mode-sessions";
+  const canonSpacesPath = path.join(orgDir(base, agentTree, canon), "spaces.json");
+  const merged = new Map;
+  for (const sp of readSpaces(canonSpacesPath))
+    if (sp && sp.id)
+      merged.set(sp.id, sp);
+  const before = merged.size;
+  const sourcePlanBySource = new Map(sourcePlans.map((sp) => [sp.source.key, sp]));
+  for (const s of sources) {
+    const added2 = [];
+    for (const sp of readSpaces(path.join(orgDir(base, agentTree, s), "spaces.json"))) {
+      if (sp && sp.id && !merged.has(sp.id)) {
+        merged.set(sp.id, sp);
+        added2.push(sp);
+      }
+    }
+    const sourcePlan = sourcePlanBySource.get(s.key);
+    if (sourcePlan)
+      sourcePlan.spacesAdded = added2;
+  }
+  const mergedArr = [...merged.values()];
+  for (const sp of mergedArr)
+    if (sp && sp.id)
+      spaceIds.add(sp.id);
+  const added = mergedArr.length - before;
+  const spacesMerge = mergedArr.length === 0 ? null : {
+    canonPath: canonSpacesPath,
+    before,
+    merged: mergedArr,
+    added,
+    willWrite: added > 0 || !exists(canonSpacesPath)
+  };
+  const linkPlans = [];
+  if (linkMode) {
+    const stamp = timestamp();
+    for (const s of sources) {
+      for (const tree of TREES) {
+        const srcDir = orgDir(base, tree, s);
+        if (!exists(srcDir))
+          continue;
+        linkPlans.push({
+          tree,
+          source: s,
+          srcDir,
+          canonDir: orgDir(base, tree, canon),
+          backupDir: `${srcDir}.bak-${stamp}`,
+          alreadySymlink: isSymlink(srcDir)
+        });
+      }
+    }
+  }
+  return { canonical: canon, sourcePlans, spacesMerge, linkPlans, sessionIds, spaceIds };
+}
+function timestamp() {
+  return new Date().toISOString().replace(/[:.]/g, "-");
+}
+function listCapped(items, cap = 20) {
+  if (items.length <= cap)
+    return items;
+  return [...items.slice(0, cap), c.dim(`... and ${items.length - cap} more`)];
+}
+function printPlan(plan, linkMode) {
+  const out = process.stdout;
+  out.write(`
+` + c.bold("PLAN") + `
+`);
+  out.write(`  Canonical: ${c.cyan(plan.canonical.key)}
+`);
+  let totalCopyFiles = 0;
+  let totalCopyDirs = 0;
+  let totalConflicts = 0;
+  for (const sp of plan.sourcePlans) {
+    out.write(`
+  ${c.bold("Source")} ${c.blue(sp.source.key)}
+`);
+    if (sp.source.key === plan.canonical.key) {
+      out.write(`    ${c.dim("(same as canonical — skipped)")}
+`);
+      continue;
+    }
+    for (const tree of TREES) {
+      const copies = sp.copies.filter((x) => x.tree === tree);
+      const conflicts = sp.conflicts.filter((x) => x.tree === tree);
+      if (copies.length === 0 && conflicts.length === 0) {
+        out.write(`    [${tree}] ${c.dim("nothing to copy")}
+`);
+        continue;
+      }
+      const files = copies.filter((x) => x.kind === "file");
+      const dirs = copies.filter((x) => x.kind === "dir");
+      totalCopyFiles += files.length;
+      totalCopyDirs += dirs.length;
+      totalConflicts += conflicts.length;
+      out.write(`    [${tree}] copy ${c.green(String(files.length))} files, ${c.green(String(dirs.length))} dirs; ` + `${conflicts.length ? c.yellow(String(conflicts.length)) : "0"} conflicts (kept canonical)
+`);
+      for (const line of listCapped(files.map((x) => `      + ${x.name}`)))
+        out.write(line + `
+`);
+      for (const line of listCapped(dirs.map((x) => `      + ${x.name}/  (dir)`)))
+        out.write(line + `
+`);
+      for (const x of conflicts.slice(0, 20)) {
+        const why = x.reason === "differs" ? "differs" : "dir exists";
+        out.write(`      ${c.yellow("!")} ${x.name}${x.kind === "dir" ? "/" : ""}  (${why}, kept canonical)
+`);
+      }
+    }
+    if (sp.identical > 0)
+      out.write(`    ${c.dim(`(${sp.identical} identical file(s) skipped)`)}
+`);
+    if (sp.spacesAdded.length > 0)
+      out.write(`    spaces.json: ${c.green("+" + sp.spacesAdded.length)} new space(s)
+`);
+  }
+  if (plan.spacesMerge) {
+    const m = plan.spacesMerge;
+    out.write(`
+  ${c.bold("spaces.json (canonical)")}: ${m.before} existing, ${c.green("+" + m.added)} added, ` + `${m.merged.length} total${m.willWrite ? "" : c.dim(" (no write needed)")}
+`);
+  }
+  if (linkMode) {
+    out.write(`
+` + c.red(c.bold("  LINK (DESTRUCTIVE) — Step B")) + `
+`);
+    out.write(c.dim("  Each source org dir is backed up to ") + c.cyan("*.bak-<timestamp>") + c.dim(` before it becomes a symlink, so this is
+  fully reversible — undo it later with `) + c.bold("--revert") + c.dim(` (restores the backups).
+`));
+    out.write(c.yellow(`  ⚠  QUIT the Claude desktop app before applying LINK, or it may recreate/overwrite these dirs.
+`));
+    if (plan.linkPlans.length === 0)
+      out.write(`    ${c.dim("no source org dirs to link")}
+`);
+    for (const lp of plan.linkPlans) {
+      if (lp.alreadySymlink) {
+        out.write(`    [${lp.tree}] ${c.dim(`${lp.srcDir} is already a symlink — skipped`)}
+`);
+        continue;
+      }
+      out.write(`    [${lp.tree}] ${c.blue(lp.source.key)}
+`);
+      out.write(`        backup:  ${lp.srcDir}
+`);
+      out.write(`             ->  ${lp.backupDir}
+`);
+      out.write(`        symlink: ${lp.srcDir} -> ${c.cyan(lp.canonDir)}
+`);
+    }
+  }
+  out.write(`
+  ${c.bold("Totals")}: ${totalCopyFiles} file(s) + ${totalCopyDirs} dir(s) to copy, ` + `${totalConflicts} conflict(s) kept, ${plan.spacesMerge ? plan.spacesMerge.added : 0} space(s) added` + (linkMode ? `, ${plan.linkPlans.filter((l) => !l.alreadySymlink).length} dir(s) to symlink` : "") + `
+`);
+}
+function executePlan(plan, linkMode) {
+  const r = { copiedFiles: 0, copiedDirs: 0, spacesWritten: false, linked: 0, backedUp: 0, errors: [] };
+  for (const sp of plan.sourcePlans) {
+    if (sp.source.key === plan.canonical.key)
+      continue;
+    for (const item of sp.copies) {
+      try {
+        fs.mkdirSync(path.dirname(item.dest), { recursive: true });
+        if (item.kind === "dir") {
+          fs.cpSync(item.src, item.dest, { recursive: true });
+          r.copiedDirs += 1;
+        } else {
+          fs.copyFileSync(item.src, item.dest);
+          r.copiedFiles += 1;
+        }
+      } catch (err) {
+        r.errors.push(`copy ${item.src} -> ${item.dest}: ${err.message}`);
+      }
+    }
+  }
+  if (plan.spacesMerge && plan.spacesMerge.willWrite) {
+    try {
+      fs.mkdirSync(path.dirname(plan.spacesMerge.canonPath), { recursive: true });
+      fs.writeFileSync(plan.spacesMerge.canonPath, JSON.stringify({ spaces: plan.spacesMerge.merged }, null, 2));
+      r.spacesWritten = true;
+    } catch (err) {
+      r.errors.push(`write ${plan.spacesMerge.canonPath}: ${err.message}`);
+    }
+  }
+  if (linkMode) {
+    for (const lp of plan.linkPlans) {
+      if (lp.alreadySymlink)
+        continue;
+      try {
+        fs.mkdirSync(lp.canonDir, { recursive: true });
+        fs.renameSync(lp.srcDir, lp.backupDir);
+        r.backedUp += 1;
+        fs.symlinkSync(lp.canonDir, lp.srcDir);
+        r.linked += 1;
+      } catch (err) {
+        r.errors.push(`link ${lp.srcDir}: ${err.message}`);
+      }
+    }
+  }
+  return r;
+}
+function levelDbReport(base, plan) {
+  const out = process.stdout;
+  out.write(`
+` + c.bold("LevelDB pin/group report") + c.dim(" (read-only, best-effort)") + `
+`);
+  const dbDir = path.join(base, "Local Storage", "leveldb");
+  try {
+    if (!isDir(dbDir)) {
+      out.write(`  ${c.dim("no leveldb store found — skipping")}
+`);
+      return;
+    }
+    const files = fs.readdirSync(dbDir).filter((n) => n.endsWith(".ldb") || n.endsWith(".log")).map((n) => path.join(dbDir, n));
+    const needles = [...plan.sessionIds, ...plan.spaceIds];
+    const found = new Set;
+    for (const file of files) {
+      let hay;
+      try {
+        hay = fs.readFileSync(file).toString("latin1");
+      } catch {
+        continue;
+      }
+      for (const id of needles)
+        if (!found.has(id) && hay.includes(id))
+          found.add(id);
+    }
+    if (needles.length === 0) {
+      out.write(`  ${c.dim("no session/space ids in scope")}
+`);
+      return;
+    }
+    out.write(`  ${found.size}/${needles.length} merged id(s) are referenced by leveldb (pins/groups/stars/sort).
+`);
+    for (const id of [...found].slice(0, 15))
+      out.write(`    ${c.cyan("•")} ${id}
+`);
+    if (found.size > 15)
+      out.write(`    ${c.dim(`... and ${found.size - 15} more`)}
+`);
+    out.write(c.dim(`  Note: leveldb is a single global store shared app-wide; it is NEVER modified by this tool.
+` + `  Pins/groups reference sessions by id, so they follow the merged sessions automatically.
+`));
+  } catch (err) {
+    out.write(`  ${c.yellow("leveldb scan failed:")} ${err.message}
+`);
+  }
+}
+function requireTty(what) {
+  if (stdin.isTTY !== true)
+    fail(`${what} requires an interactive terminal. Pass it via flags instead (see --help).`);
+}
+function matchLocation(key, locations) {
+  const found = locations.find((l) => l.key === key);
+  if (!found)
+    fail(`location not found: ${key} (must be one of the discovered <account>/<org> pairs)`);
+  return found;
+}
+async function pickCanonical(rl, locations) {
+  while (true) {
+    const ans = (await rl.question(c.bold(`
+Choose CANONICAL location (number): `))).trim();
+    const n = Number(ans);
+    if (Number.isInteger(n) && n >= 1 && n <= locations.length)
+      return locations[n - 1];
+    process.stdout.write(c.yellow(`  enter a number between 1 and ${locations.length}
+`));
+  }
+}
+async function pickSources(rl, locations, canonical) {
+  const others = locations.filter((l) => l.key !== canonical.key);
+  if (others.length === 0)
+    return [];
+  while (true) {
+    const ans = (await rl.question(c.bold("Choose SOURCE location(s) — comma-separated numbers, or 'a' for all others: "))).trim();
+    if (ans.toLowerCase() === "a")
+      return others;
+    const nums = ans.split(",").map((s) => Number(s.trim()));
+    const valid = nums.every((n) => Number.isInteger(n) && n >= 1 && n <= locations.length);
+    if (valid && nums.length > 0) {
+      const picked = [...new Set(nums)].map((n) => locations[n - 1]).filter((l) => l.key !== canonical.key);
+      if (picked.length > 0)
+        return picked;
+    }
+    process.stdout.write(c.yellow(`  enter valid numbers (not the canonical), or 'a'
+`));
+  }
+}
+async function pickLinkMode(rl) {
+  while (true) {
+    const ans = (await rl.question(c.bold(`
+1) MERGE only   2) MERGE then LINK (destructive) — choose [1/2]: `))).trim();
+    if (ans === "1")
+      return false;
+    if (ans === "2")
+      return true;
+    process.stdout.write(c.yellow(`  enter 1 or 2
+`));
+  }
+}
+async function confirm(rl, message) {
+  const ans = (await rl.question(c.bold(message + " Type 'yes' to proceed: "))).trim();
+  return ans.toLowerCase() === "yes";
+}
+function readLinkSafe(p) {
+  try {
+    return fs.readlinkSync(p);
+  } catch {
+    return null;
+  }
+}
+var BACKUP_RE = /^(.*)\.bak-(.+)$/;
+function discoverBackups(base) {
+  const out = [];
+  for (const tree of TREES) {
+    const treeDir = path.join(base, tree);
+    if (!isDir(treeDir))
+      continue;
+    for (const account of listDirs(treeDir)) {
+      const accDir = path.join(treeDir, account);
+      let dirents;
+      try {
+        dirents = fs.readdirSync(accDir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const d of dirents) {
+        const m = d.name.match(BACKUP_RE);
+        if (!m)
+          continue;
+        const backupDir = path.join(accDir, d.name);
+        if (!isDir(backupDir))
+          continue;
+        const originalDir = path.join(accDir, m[1]);
+        const currentExists = exists(originalDir);
+        const currentIsSymlink = isSymlink(originalDir);
+        out.push({
+          tree,
+          account,
+          originalName: m[1],
+          stamp: m[2],
+          backupDir,
+          originalDir,
+          currentExists,
+          currentIsSymlink,
+          currentIsRealDir: currentExists && !currentIsSymlink && isDir(originalDir),
+          symlinkTarget: currentIsSymlink ? readLinkSafe(originalDir) : null
+        });
+      }
+    }
+  }
+  return out.sort((a, b) => a.tree.localeCompare(b.tree) || a.account.localeCompare(b.account) || a.originalName.localeCompare(b.originalName) || a.stamp.localeCompare(b.stamp));
+}
+function buildRevertItems(backups) {
+  const groups = new Map;
+  for (const b of backups) {
+    const key = `${b.tree}\x00${b.account}\x00${b.originalName}`;
+    const arr = groups.get(key) ?? [];
+    arr.push(b);
+    groups.set(key, arr);
+  }
+  const items = [];
+  for (const arr of groups.values()) {
+    arr.sort((a, b) => b.stamp.localeCompare(a.stamp));
+    const [chosen, ...older] = arr;
+    let action = "restore";
+    let reason;
+    if (chosen.currentIsRealDir) {
+      action = "conflict";
+      reason = "a real directory (not a symlink) sits at the original path";
+    } else if (chosen.currentExists && !chosen.currentIsSymlink) {
+      action = "conflict";
+      reason = "an unexpected non-directory entry sits at the original path";
+    }
+    items.push({ chosen, older, action, reason });
+  }
+  return items.sort((a, b) => a.chosen.tree.localeCompare(b.chosen.tree) || a.chosen.account.localeCompare(b.chosen.account) || a.chosen.originalName.localeCompare(b.chosen.originalName));
+}
+function printRevertPlan(items) {
+  const out = process.stdout;
+  out.write(`
+` + c.bold("REVERT PLAN") + c.dim(" (undo --link)") + `
+`);
+  if (items.length === 0) {
+    out.write(`  ${c.dim("no *.bak-<stamp> backups found — nothing to revert.")}
+`);
+    return;
+  }
+  let restores = 0;
+  let conflicts = 0;
+  for (const it of items) {
+    const b = it.chosen;
+    const loc = `${b.account}/${b.originalName}`;
+    if (it.action === "conflict") {
+      conflicts += 1;
+      out.write(`    [${b.tree}] ${c.yellow("!")} ${c.blue(loc)}  ${c.yellow("(skipped: " + it.reason + ")")}
+`);
+    } else {
+      restores += 1;
+      const cur = b.currentIsSymlink ? `symlink -> ${b.symlinkTarget ?? "?"}` : b.currentExists ? "existing entry" : c.dim("(nothing there)");
+      out.write(`    [${b.tree}] ${c.green("↺")} ${c.blue(loc)}
+`);
+      out.write(`        current: ${cur}
+`);
+      out.write(`        restore: ${c.cyan(b.backupDir)}
+`);
+      out.write(`             ->  ${b.originalDir}
+`);
+    }
+    if (it.older.length > 0)
+      out.write(`        ${c.dim(`(${it.older.length} older backup(s) left in place)`)}
+`);
+  }
+  out.write(`
+  ${c.bold("Totals")}: ${c.green(String(restores))} to restore, ` + `${conflicts ? c.yellow(String(conflicts)) : "0"} conflict(s) skipped
+`);
+}
+function executeRevert(items) {
+  const r = { restored: 0, removedSymlinks: 0, errors: [] };
+  for (const it of items) {
+    if (it.action !== "restore")
+      continue;
+    const b = it.chosen;
+    try {
+      if (b.currentIsSymlink) {
+        fs.unlinkSync(b.originalDir);
+        r.removedSymlinks += 1;
+      }
+      if (exists(b.originalDir)) {
+        r.errors.push(`restore ${b.originalDir}: path still exists after clearing symlink — skipped`);
+        continue;
+      }
+      fs.renameSync(b.backupDir, b.originalDir);
+      r.restored += 1;
+    } catch (err) {
+      r.errors.push(`restore ${b.backupDir} -> ${b.originalDir}: ${err.message}`);
+    }
+  }
+  return r;
+}
+async function runRevert(base, args) {
+  process.stdout.write(c.bold("claude-desktop-merge") + c.dim(" — revert (macOS)") + `
+`);
+  process.stdout.write(`BASE: ${c.cyan(base)}
+`);
+  const items = buildRevertItems(discoverBackups(base));
+  printRevertPlan(items);
+  const restorable = items.filter((it) => it.action === "restore");
+  if (!args.apply) {
+    process.stdout.write(`
+` + c.bold(c.yellow("DRY RUN — no filesystem changes were made.")) + `
+`);
+    if (restorable.length > 0)
+      process.stdout.write(c.dim(`Re-run with --revert --apply to restore the backups above.
+`));
+    return;
+  }
+  if (restorable.length === 0) {
+    process.stdout.write(`
+` + c.green("Nothing to restore — done.") + `
+`);
+    return;
+  }
+  process.stdout.write(`
+` + c.yellow(`⚠  QUIT the Claude desktop app before reverting, or it may recreate the symlinked dirs.
+`));
+  if (!args.yes) {
+    requireTty("Confirmation");
+    const rl = readline.createInterface({ input: stdin, output: stdout });
+    try {
+      const ok = await confirm(rl, "Proceed with REVERT (restore pre-symlink backups)?");
+      if (!ok) {
+        process.stdout.write(c.yellow(`Aborted — no changes made.
+`));
+        return;
+      }
+    } finally {
+      rl.close();
+    }
+  }
+  const result = executeRevert(items);
+  process.stdout.write(`
+` + c.bold("SUMMARY") + `
+`);
+  process.stdout.write(`  Restored: ${c.green(String(result.restored))} dir(s) (${result.removedSymlinks} symlink(s) removed)
+`);
+  if (result.errors.length) {
+    process.stdout.write(c.red(`  ${result.errors.length} error(s):
+`));
+    for (const e of result.errors)
+      process.stdout.write(c.red(`    - ${e}
+`));
+  }
+  process.stdout.write(`
+` + c.cyan("Reopen the Claude desktop app to confirm each account shows its own sessions again.") + `
+`);
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    printHelp();
+    return;
+  }
+  if (process.platform !== "darwin")
+    fail(`this tool is macOS-only (detected platform: ${process.platform}).`);
+  const base = path.join(os.homedir(), "Library/Application Support/Claude");
+  if (!isDir(base))
+    fail(`Claude desktop data dir not found at:
+  ${base}
+Is the Claude desktop app installed for this user?`);
+  if (!args.noLog) {
+    initLogging(args.logFile, process.argv.slice(2));
+    if (logFilePath)
+      process.stdout.write(c.dim(`Logging to: ${logFilePath}`) + `
+`);
+  }
+  if (args.revert) {
+    try {
+      await runRevert(base, args);
+    } finally {
+      closeLogging();
+    }
+    return;
+  }
+  const config = readJson(path.join(base, "config.json")) || {};
+  const activeAccount = config.lastKnownAccountUuid;
+  process.stdout.write(c.bold("claude-desktop-merge") + c.dim(" (macOS)") + `
+`);
+  process.stdout.write(`BASE: ${c.cyan(base)}
+`);
+  process.stdout.write(`Active account (lastKnownAccountUuid): ${activeAccount ? c.green(activeAccount) : c.yellow("unknown")}
+`);
+  const locations = discoverLocations(base);
+  if (locations.length === 0)
+    fail("no session locations discovered under either tree.");
+  process.stdout.write(`
+` + c.bold("Discovered locations:") + `
+`);
+  locations.forEach((loc, i) => {
+    const s = summarizeLocation(base, loc);
+    const activeMark = loc.account === activeAccount ? c.green("  [ACTIVE]") : "";
+    process.stdout.write(`  ${c.bold(String(i + 1))}) ${c.cyan(loc.key)}  ${c.dim(`(${s.total} sessions)`)}${activeMark}
+`);
+    for (const t of s.recentTitles)
+      process.stdout.write(`       ${c.dim("· " + t)}
+`);
+  });
+  const needCanonicalPick = !args.canonical;
+  const needSourcePick = !args.sources && !args.allOthers;
+  const interactive = needCanonicalPick || needSourcePick;
+  let rl = null;
+  const getRl = () => {
+    if (!rl)
+      rl = readline.createInterface({ input: stdin, output: stdout });
+    return rl;
+  };
+  try {
+    let canonical;
+    if (args.canonical)
+      canonical = matchLocation(args.canonical, locations);
+    else {
+      requireTty("Choosing the canonical location");
+      canonical = await pickCanonical(getRl(), locations);
+    }
+    let sources;
+    if (args.allOthers)
+      sources = locations.filter((l) => l.key !== canonical.key);
+    else if (args.sources) {
+      sources = args.sources.map((k) => matchLocation(k, locations)).filter((l) => l.key !== canonical.key);
+    } else {
+      requireTty("Choosing source locations");
+      sources = await pickSources(getRl(), locations, canonical);
+    }
+    let linkMode;
+    if (args.link)
+      linkMode = true;
+    else if (interactive)
+      linkMode = await pickLinkMode(getRl());
+    else
+      linkMode = false;
+    process.stdout.write(`
+` + c.bold("Selection:") + `
+`);
+    process.stdout.write(`  Canonical: ${c.cyan(canonical.key)}
+`);
+    process.stdout.write(`  Sources:   ${sources.length ? sources.map((s) => c.blue(s.key)).join(", ") : c.dim("(none)")}
+`);
+    process.stdout.write(`  Mode:      ${linkMode ? c.red("MERGE + LINK (destructive)") : c.green("MERGE only")}
+`);
+    if (sources.length === 0)
+      process.stdout.write(c.yellow(`
+No source locations differ from canonical — nothing to merge. (This is a valid no-op.)
+`));
+    const plan = buildPlan(base, canonical, sources, linkMode);
+    printPlan(plan, linkMode);
+    if (!args.apply) {
+      process.stdout.write(`
+` + c.bold(c.yellow("DRY RUN — no filesystem changes were made.")) + `
+`);
+      process.stdout.write(c.dim(`Re-run with --apply to execute the plan above.
+`));
+      levelDbReport(base, plan);
+      return;
+    }
+    const hasWork = plan.sourcePlans.some((sp) => sp.copies.length > 0) || (plan.spacesMerge?.willWrite ?? false) || plan.linkPlans.some((lp) => !lp.alreadySymlink);
+    if (!hasWork) {
+      process.stdout.write(`
+` + c.green("Nothing to apply — plan is a no-op. Done.") + `
+`);
+      levelDbReport(base, plan);
+      return;
+    }
+    if (linkMode)
+      process.stdout.write(`
+` + c.red(c.bold("⚠  DESTRUCTIVE: LINK will back up and REPLACE source org dirs with symlinks.")) + `
+` + c.dim("   A ") + c.cyan("*.bak-<timestamp>") + c.dim(" copy of each dir is kept — reverse it anytime with ") + c.bold("--revert") + c.dim(`.
+`) + c.yellow(`   QUIT the Claude desktop app now, before proceeding.
+`));
+    if (!args.yes) {
+      requireTty("Confirmation");
+      const ok = await confirm(getRl(), linkMode ? "Proceed with MERGE + LINK?" : "Proceed with MERGE?");
+      if (!ok) {
+        process.stdout.write(c.yellow(`Aborted — no changes made.
+`));
+        return;
+      }
+    }
+    const result = executePlan(plan, linkMode);
+    process.stdout.write(`
+` + c.bold("SUMMARY") + `
+`);
+    process.stdout.write(`  Copied: ${c.green(String(result.copiedFiles))} file(s), ${c.green(String(result.copiedDirs))} dir(s)
+`);
+    process.stdout.write(`  spaces.json: ${result.spacesWritten ? c.green("written") : c.dim("unchanged")}
+`);
+    if (linkMode)
+      process.stdout.write(`  Linked: ${c.green(String(result.linked))} dir(s) symlinked, ${result.backedUp} backed up
+`);
+    if (linkMode && result.linked > 0)
+      process.stdout.write(c.dim("  Undo anytime with ") + c.bold("--revert --apply") + c.dim(` (restores the *.bak-<ts> backups).
+`));
+    if (result.errors.length) {
+      process.stdout.write(c.red(`  ${result.errors.length} error(s):
+`));
+      for (const e of result.errors)
+        process.stdout.write(c.red(`    - ${e}
+`));
+    }
+    levelDbReport(base, plan);
+    process.stdout.write(`
+` + c.cyan("Reopen the Claude desktop app to see the merged sessions.") + `
+`);
+  } finally {
+    if (rl)
+      rl.close();
+    closeLogging();
+  }
+}
+main().catch((err) => {
+  process.stderr.write(c.red(`
+unexpected error: ${err.stack || err}`) + `
+`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "claude-desktop-merge",
+  "version": "1.0.0",
+  "description": "Merge & sync Claude desktop-app sessions across accounts (macOS, zero-dependency, dry-run by default).",
+  "keywords": [
+    "claude",
+    "claude-desktop",
+    "sessions",
+    "merge",
+    "accounts",
+    "macos",
+    "cli"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "os": [
+    "darwin"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sebryu/claude-desktop-merge.git"
+  },
+  "homepage": "https://github.com/sebryu/claude-desktop-merge#readme",
+  "bugs": {
+    "url": "https://github.com/sebryu/claude-desktop-merge/issues"
+  },
+  "bin": {
+    "claude-desktop-merge": "dist/claude-desktop-merge.mjs"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "bun build ./claude-desktop-merge.ts --target=node --outfile dist/claude-desktop-merge.mjs && chmod +x dist/claude-desktop-merge.mjs",
+    "prepublishOnly": "bun run build",
+    "start": "bun claude-desktop-merge.ts"
+  }
+}