claude-desktop-merge 1.0.0 → 1.1.0

package/README.md

@@ -98,12 +98,13 @@ The macOS desktop app keeps two different things in two different places:
 |---|---|---|
 | **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 |
+| **Routines** (scheduled tasks: cron, model, enabled state) | `…/{claude-code-sessions,local-agent-mode-sessions}/<accountUuid>/<orgUuid>/scheduled-tasks.json` | **Yes** — one file per account/org, per tree |
 
 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.
+1. **MERGE** (non-destructive) — pick one **canonical** `<account>/<org>`. Copy the pointer files that exist only in other accounts *into* canonical. Union `spaces.json` and `scheduled-tasks.json` (your **routines**) by id — canonical wins on any collision. 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.

package/dist/claude-desktop-merge.mjs

@@ -166,9 +166,10 @@ ${b("FLAGS")}
 
 ${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.
+  pointer files/dirs from sources INTO canonical across both trees and unions spaces.json plus
+  scheduled-tasks.json ("routines") 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
@@ -207,7 +208,7 @@ function readOrgEntries(dir) {
     return out;
   }
   for (const d of dirents) {
-    if (d.name === "spaces.json")
+    if (d.name === "spaces.json" || d.name === "scheduled-tasks.json")
       continue;
     const full = path.join(dir, d.name);
     const entryIsDir = d.isDirectory() || d.isSymbolicLink() && isDir(full);
@@ -244,8 +245,14 @@ function readSpaces(spacesPath) {
     return data.spaces;
   return [];
 }
+function readScheduledTasks(tasksPath) {
+  const data = readJson(tasksPath);
+  const tasks = data && Array.isArray(data.scheduledTasks) ? data.scheduledTasks : [];
+  const recordedSkips = data && data.recordedSkips && typeof data.recordedSkips === "object" && !Array.isArray(data.recordedSkips) ? data.recordedSkips : {};
+  return { tasks, recordedSkips };
+}
 function buildSourcePlan(base, canon, source) {
-  const plan = { source, copies: [], conflicts: [], identical: 0, spacesAdded: [] };
+  const plan = { source, copies: [], conflicts: [], identical: 0, spacesAdded: [], routinesAdded: [] };
   for (const tree of TREES) {
     const srcDir = orgDir(base, tree, source);
     const canonDir = orgDir(base, tree, canon);
@@ -330,6 +337,47 @@ function buildPlan(base, canon, sources, linkMode) {
     added,
     willWrite: added > 0 || !exists(canonSpacesPath)
   };
+  const routinesMerges = [];
+  for (const tree of TREES) {
+    const canonTasksPath = path.join(orgDir(base, tree, canon), "scheduled-tasks.json");
+    const canonTasks = readScheduledTasks(canonTasksPath);
+    const mergedTasks = new Map;
+    for (const t of canonTasks.tasks)
+      if (t && t.id)
+        mergedTasks.set(t.id, t);
+    const tasksBefore = mergedTasks.size;
+    const mergedSkips = { ...canonTasks.recordedSkips };
+    const skipsBefore = Object.keys(mergedSkips).length;
+    for (const s of sources) {
+      const srcTasks = readScheduledTasks(path.join(orgDir(base, tree, s), "scheduled-tasks.json"));
+      const sourcePlan = sourcePlanBySource.get(s.key);
+      for (const t of srcTasks.tasks) {
+        if (t && t.id && !mergedTasks.has(t.id)) {
+          mergedTasks.set(t.id, t);
+          if (sourcePlan)
+            sourcePlan.routinesAdded.push({ tree, task: t });
+        }
+      }
+      for (const [k, v] of Object.entries(srcTasks.recordedSkips)) {
+        if (!(k in mergedSkips))
+          mergedSkips[k] = v;
+      }
+    }
+    const tasksArr = [...mergedTasks.values()];
+    const skipCount = Object.keys(mergedSkips).length;
+    if (tasksArr.length === 0 && skipCount === 0)
+      continue;
+    routinesMerges.push({
+      tree,
+      canonPath: canonTasksPath,
+      before: tasksBefore,
+      mergedTasks: tasksArr,
+      addedTasks: tasksArr.length - tasksBefore,
+      recordedSkips: mergedSkips,
+      skipsAdded: skipCount - skipsBefore,
+      willWrite: tasksArr.length - tasksBefore > 0 || skipCount - skipsBefore > 0 || !exists(canonTasksPath)
+    });
+  }
   const linkPlans = [];
   if (linkMode) {
     const stamp = timestamp();
@@ -349,7 +397,7 @@ function buildPlan(base, canon, sources, linkMode) {
       }
     }
   }
-  return { canonical: canon, sourcePlans, spacesMerge, linkPlans, sessionIds, spaceIds };
+  return { canonical: canon, sourcePlans, spacesMerge, routinesMerges, linkPlans, sessionIds, spaceIds };
 }
 function timestamp() {
   return new Date().toISOString().replace(/[:.]/g, "-");
@@ -411,11 +459,23 @@ function printPlan(plan, linkMode) {
     if (sp.spacesAdded.length > 0)
       out.write(`    spaces.json: ${c.green("+" + sp.spacesAdded.length)} new space(s)
 `);
+    if (sp.routinesAdded.length > 0) {
+      out.write(`    scheduled-tasks.json: ${c.green("+" + sp.routinesAdded.length)} new routine(s)
+`);
+      for (const line of listCapped(sp.routinesAdded.map((r) => `      + ${r.task?.id ?? "(unnamed)"}  ${c.dim("[" + r.tree + "]")}`)))
+        out.write(line + `
+`);
+    }
   }
   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)")}
+`);
+  }
+  for (const rm of plan.routinesMerges) {
+    out.write(`
+  ${c.bold("scheduled-tasks.json (canonical)")} ${c.dim("[" + rm.tree + "]")}: ${rm.before} existing, ` + `${c.green("+" + rm.addedTasks)} added, ${rm.mergedTasks.length} total` + (rm.skipsAdded > 0 ? `, ${c.green("+" + rm.skipsAdded)} skip record(s)` : "") + `${rm.willWrite ? "" : c.dim(" (no write needed)")}
 `);
   }
   if (linkMode) {
@@ -446,12 +506,21 @@ function printPlan(plan, linkMode) {
 `);
     }
   }
+  const totalRoutinesAdded = plan.routinesMerges.reduce((n, rm) => n + rm.addedTasks, 0);
   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` : "") + `
+  ${c.bold("Totals")}: ${totalCopyFiles} file(s) + ${totalCopyDirs} dir(s) to copy, ` + `${totalConflicts} conflict(s) kept, ${plan.spacesMerge ? plan.spacesMerge.added : 0} space(s) added, ` + `${totalRoutinesAdded} routine(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: [] };
+  const r = {
+    copiedFiles: 0,
+    copiedDirs: 0,
+    spacesWritten: false,
+    routinesWritten: 0,
+    linked: 0,
+    backedUp: 0,
+    errors: []
+  };
   for (const sp of plan.sourcePlans) {
     if (sp.source.key === plan.canonical.key)
       continue;
@@ -479,6 +548,17 @@ function executePlan(plan, linkMode) {
       r.errors.push(`write ${plan.spacesMerge.canonPath}: ${err.message}`);
     }
   }
+  for (const rm of plan.routinesMerges) {
+    if (!rm.willWrite)
+      continue;
+    try {
+      fs.mkdirSync(path.dirname(rm.canonPath), { recursive: true });
+      fs.writeFileSync(rm.canonPath, JSON.stringify({ scheduledTasks: rm.mergedTasks, recordedSkips: rm.recordedSkips }, null, 2));
+      r.routinesWritten += 1;
+    } catch (err) {
+      r.errors.push(`write ${rm.canonPath}: ${err.message}`);
+    }
+  }
   if (linkMode) {
     for (const lp of plan.linkPlans) {
       if (lp.alreadySymlink)
@@ -899,7 +979,7 @@ No source locations differ from canonical — nothing to merge. (This is a valid
       levelDbReport(base, plan);
       return;
     }
-    const hasWork = plan.sourcePlans.some((sp) => sp.copies.length > 0) || (plan.spacesMerge?.willWrite ?? false) || plan.linkPlans.some((lp) => !lp.alreadySymlink);
+    const hasWork = plan.sourcePlans.some((sp) => sp.copies.length > 0) || (plan.spacesMerge?.willWrite ?? false) || plan.routinesMerges.some((rm) => rm.willWrite) || plan.linkPlans.some((lp) => !lp.alreadySymlink);
     if (!hasWork) {
       process.stdout.write(`
 ` + c.green("Nothing to apply — plan is a no-op. Done.") + `
@@ -929,6 +1009,8 @@ No source locations differ from canonical — nothing to merge. (This is a valid
     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")}
+`);
+    process.stdout.write(`  scheduled-tasks.json: ${result.routinesWritten > 0 ? c.green(result.routinesWritten + " file(s) written") : c.dim("unchanged")}
 `);
     if (linkMode)
       process.stdout.write(`  Linked: ${c.green(String(result.linked))} dir(s) symlinked, ${result.backedUp} backed up
@@ -945,7 +1027,7 @@ No source locations differ from canonical — nothing to merge. (This is a valid
     }
     levelDbReport(base, plan);
     process.stdout.write(`
-` + c.cyan("Reopen the Claude desktop app to see the merged sessions.") + `
+` + c.cyan("Reopen the Claude desktop app to see the merged sessions and routines.") + `
 `);
   } finally {
     if (rl)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-desktop-merge",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Merge & sync Claude desktop-app sessions across accounts (macOS, zero-dependency, dry-run by default).",
   "keywords": [
     "claude",