Bundle DreamNode git-init template into the plugin, not the InterBrain repo

Root cause of "ENOENT .git/udd" on fresh installs: the template path
keyed off <vault>/InterBrain/src/features/dreamnode/DreamNode-template/
— but on a fresh install the daemon clones the InterBrain DreamNode
from `main`, which is docs-only and has NO `src/` tree. The template
never resolved, so every DreamNode creation (including the auto-created
sender Dreamer node on invite-accept) failed.

Fix: the template now ships INSIDE the plugin install dir.
  - assemble-plugin.mjs stages src/features/dreamnode/DreamNode-template/
    → repo-root DreamNode-template/ (gitignored, like main.js)
  - copy-plugin-resources.mjs carries it into the Tauri resource bundle
  - install_managed copies it into <vault>/.obsidian/plugins/<id>/
    DreamNode-template/ (new copy_dir_recursive helper)
  - ensure_plugin_health treats a managed dir missing the template as
    unhealthy → re-stages it (so older installs self-heal on next
    daemon startup)
  - git-dreamnode-service.ts templatePath → <pluginDir>/DreamNode-template

Now DreamNode creation works on any fresh install regardless of which
branch the InterBrain DreamNode repo was cloned from.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ProjectLiminality

.gitignore

@@ -105,6 +105,10 @@ dist
 /main.js
 *.zip
 /styles.css
+# Staged copy of the DreamNode git-init template — assemble-plugin.mjs
+# copies it here from src/features/dreamnode/DreamNode-template/ (the
+# source of truth) so it gets bundled into the plugin install dir.
+/DreamNode-template/
 
 # macOS
 .DS_Store

desktop/scripts/copy-plugin-resources.mjs

@@ -7,7 +7,7 @@
  *
  * Run automatically before `tauri build` and `vite build`.
  */
-import { copyFileSync, existsSync, mkdirSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, cpSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -24,6 +24,16 @@ const items = [
   ['theme/interbrain.css', 'interbrain.css'],
 ];
 
+// Directories to copy wholesale (sourceRelativeToRepo, dstNameInResourceDir).
+const dirItems = [
+  // The DreamNode git-init template. assemble-plugin.mjs stages it at the
+  // repo root; we carry it into the Tauri resource bundle so the installed
+  // plugin can find it at <pluginDir>/DreamNode-template. Must NOT depend
+  // on the InterBrain DreamNode repo — that's cloned from `main` on fresh
+  // installs and has no `src/` tree.
+  ['DreamNode-template', 'DreamNode-template'],
+];
+
 mkdirSync(resourceDir, { recursive: true });
 
 const missing = [];
@@ -38,6 +48,17 @@ for (const [rel, dstName] of items) {
   console.log(`copied ${rel} → ${dst}`);
 }
 
+for (const [rel, dstName] of dirItems) {
+  const src = join(repoRoot, rel);
+  if (!existsSync(src)) {
+    missing.push(rel);
+    continue;
+  }
+  const dst = join(resourceDir, dstName);
+  cpSync(src, dst, { recursive: true });
+  console.log(`copied dir ${rel} → ${dst}`);
+}
+
 if (missing.length > 0) {
   console.error(`\nMissing plugin files at repo root: ${missing.join(', ')}`);
   console.error('Run `npm run build:plugin` from the repo root first.');

desktop/src-tauri/src/vaults.rs

@@ -211,6 +211,23 @@ pub fn install_managed(vault_path: &Path, bundled_dir: &Path) -> Result<()> {
         fs::copy(bundled_dir.join(file), staging.join(file))?;
     }
 
+    // Carry the DreamNode git-init template into the plugin install dir.
+    // The plugin reads it from <pluginDir>/DreamNode-template at runtime
+    // for `git init --template=…`. Best-effort: older bundles may not
+    // ship it, in which case DreamNode creation would fail with a clear
+    // error — but every rc.21+ build includes it.
+    let template_src = bundled_dir.join("DreamNode-template");
+    if template_src.is_dir() {
+        copy_dir_recursive(&template_src, &staging.join("DreamNode-template"))
+            .with_context(|| "stage DreamNode-template into plugin dir")?;
+    } else {
+        tracing::warn!(
+            target: "vaults",
+            path = %template_src.display(),
+            "bundled DreamNode-template missing — DreamNode creation will fail until rebuilt"
+        );
+    }
+
     // Now replace the live target — only AFTER staging is fully populated.
     if target.exists() {
         remove_path(&target)?;
@@ -304,6 +321,27 @@ fn remove_path(p: &Path) -> Result<()> {
     Ok(())
 }
 
+/// Recursively copy a directory tree. Used to stage the bundled
+/// DreamNode-template into a vault's plugin dir. Plain file/dir copy —
+/// no symlink following, no special handling; the template is just a
+/// few small files (udd, hooks/, LICENSE, README).
+fn copy_dir_recursive(src: &Path, dst: &Path) -> Result<()> {
+    fs::create_dir_all(dst)
+        .with_context(|| format!("create_dir_all {}", dst.display()))?;
+    for entry in fs::read_dir(src).with_context(|| format!("read_dir {}", src.display()))? {
+        let entry = entry?;
+        let from = entry.path();
+        let to = dst.join(entry.file_name());
+        if entry.file_type()?.is_dir() {
+            copy_dir_recursive(&from, &to)?;
+        } else {
+            fs::copy(&from, &to)
+                .with_context(|| format!("copy {} -> {}", from.display(), to.display()))?;
+        }
+    }
+    Ok(())
+}
+
 /// Clone the InterBrain repo into the vault at `<vault>/InterBrain` so the
 /// plugin source code lives alongside the user's data — the canonical
 /// "plugin code is a DreamNode" pattern. Idempotent: clones if missing,
@@ -449,8 +487,13 @@ pub fn ensure_plugin_health(
                     true
                 }
             } else if meta.is_dir() {
-                // Regular dir must contain manifest + main.js.
-                !plugin_dir.join("manifest.json").exists() || !plugin_dir.join("main.js").exists()
+                // Regular dir must contain manifest + main.js + the bundled
+                // DreamNode-template (added rc.21+; an older managed install
+                // won't have it and needs a re-stage so DreamNode creation
+                // works).
+                !plugin_dir.join("manifest.json").exists()
+                    || !plugin_dir.join("main.js").exists()
+                    || !plugin_dir.join("DreamNode-template").is_dir()
             } else {
                 true
             }

scripts/assemble-plugin.mjs

@@ -8,7 +8,7 @@
  * Replaces the POSIX `cp ... && cat ... > ...` pipeline that broke on
  * Windows. Cross-platform, idempotent.
  */
-import { copyFileSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { copyFileSync, readFileSync, writeFileSync, existsSync, cpSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -33,3 +33,20 @@ const base = existsSync(baseCss) ? readFileSync(baseCss, 'utf8') : '';
 const main = existsSync(distMainCss) ? readFileSync(distMainCss, 'utf8') : '';
 writeFileSync(outStyles, base + main, 'utf8');
 console.log(`wrote ${outStyles} (${base.length} + ${main.length} bytes)`);
+
+// Bundle the DreamNode git-init template into the plugin install dir.
+// `git init --template=<dir>` seeds every new DreamNode's .git/ with the
+// `udd` placeholder + hooks. It MUST travel with the plugin itself —
+// keying it off the InterBrain DreamNode repo (as we did before) breaks
+// on fresh installs: the daemon clones that repo from `main`, which is
+// docs-only and has no `src/` tree at all. The plugin reads this copy
+// from its own install dir via `<pluginDir>/DreamNode-template`.
+const templateSrc = join(repoRoot, 'src', 'features', 'dreamnode', 'DreamNode-template');
+const templateDst = join(repoRoot, 'DreamNode-template');
+if (existsSync(templateSrc)) {
+  cpSync(templateSrc, templateDst, { recursive: true });
+  console.log(`copied ${templateSrc} → ${templateDst}`);
+} else {
+  console.error(`assemble-plugin: missing template dir ${templateSrc}`);
+  process.exit(1);
+}

src/features/dreamnode/services/git-dreamnode-service.ts

@@ -58,24 +58,28 @@ export class GitDreamNodeService {
     }
 
     this.vaultPath = vaultPath;
-    
-    // Template lives in the InterBrain DreamNode that the daemon clones
-    // into every registered vault. Path: <vault>/InterBrain/src/features/
-    // dreamnode/DreamNode-template/. Used by `git init --template=…` to
-    // seed each new DreamNode's `.git/` directory with `udd` + hooks +
-    // README.md placeholders.
+
+    // The DreamNode git-init template ships INSIDE the plugin install dir
+    // (<vault>/.obsidian/plugins/<id>/DreamNode-template/). It's bundled
+    // there by assemble-plugin.mjs + copy-plugin-resources.mjs. Used by
+    // `git init --template=…` to seed each new DreamNode's `.git/` with
+    // the `udd` placeholder + hooks.
+    //
+    // It must NOT key off the InterBrain DreamNode repo: on a fresh
+    // install the daemon clones that repo from `main`, which is docs-only
+    // and has no `src/` tree — so the template would never resolve.
     if (this.vaultPath) {
       this.templatePath = path.join(
-        this.vaultPath, 'InterBrain', 'src', 'features', 'dreamnode', 'DreamNode-template'
+        this.vaultPath, '.obsidian', 'plugins', plugin.manifest.id, 'DreamNode-template'
       );
     } else {
-      // Pre-onload edge case (vault path not resolvable yet) — fall back to
-      // a repo-relative path that only works in dev. Production loads the
-      // adapter basePath synchronously so this branch never fires.
-      this.templatePath = './InterBrain/src/features/dreamnode/DreamNode-template';
+      // Pre-onload edge case (vault path not resolvable yet) — fall back
+      // to a repo-relative path that only works in dev. Production loads
+      // the adapter basePath synchronously so this branch never fires.
+      this.templatePath = './src/features/dreamnode/DreamNode-template';
       console.warn('GitDreamNodeService: Could not determine vault path, using fallback template path:', this.templatePath);
     }
-    
+
   }
 
   /**