shraga 0.1.46 → 0.1.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shraga",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "description": "The teammate you delegate coding to — a self-hostable, multi-user AI coding agent web UI (Claude Code, with a pluggable engine seam).",
   "type": "module",
   "main": "./src/index.ts",

package/src/server/data-sync.ts

@@ -107,8 +107,8 @@ export class DataSync {
       }
       this.ensureGitignore();
       if (!this.verifyDeploymentId()) return;
+      await this.configureGit(); // must precede untrackIgnored — it neutralises per-user excludes
       await this.untrackIgnored();
-      await this.configureGit();
       this.ready = true;
     }
 
@@ -624,7 +624,13 @@ export class DataSync {
   /** Commit a refreshed .gitignore and untrack any committed files that now match it. */
   private async untrackIgnored(): Promise<void> {
     await this.git('add', '.gitignore').catch(() => {});
-    const out = await this.git('ls-files', '-i', '-c', '--exclude-standard').catch(() => '');
+    // core.excludesFile=/dev/null: --exclude-standard would otherwise fold in the USER'S global
+    // gitignore (~/.gitignore_global) and untrack files that are ignored on this host only. The
+    // data repo is shared, so a personal rule must never decide what leaves the remote. Real
+    // near-miss 2026-08-20: a laptop's global `.agent/` rule staged 50 files for deletion —
+    // including workspace/.agent/memory/MEMORY.md, the agent's own memory — and only
+    // guardMassDeletions() stopped it. Only the repo's OWN .gitignore may untrack anything.
+    const out = await this.git('-c', 'core.excludesFile=/dev/null', 'ls-files', '-i', '-c', '--exclude-standard').catch(() => '');
     // Only untrack files that actually exist on disk AND match .gitignore.
     // git ls-files -i can falsely report tracked files missing from the worktree
     // (remote-only files restored during init). Removing those wipes remote data.
@@ -673,6 +679,8 @@ export class DataSync {
     const name = process.env.APP_NAME || 'shraga';
     await this.git('config', 'user.name', `${name} agent`).catch(() => {});
     await this.git('config', 'user.email', `agent@${name}.local`).catch(() => {});
+    // The data repo must behave identically on every host: no per-user global gitignore.
+    await this.git('config', 'core.excludesFile', '/dev/null').catch(() => {});
   }
 
   private authedUrl(): string {

package/src/server/self-upgrade/index.ts

@@ -25,6 +25,8 @@ export class SelfUpgrade {
 
   private get o(): SelfUpgradeOptions { return this.options as SelfUpgradeOptions; }
 
+  private watching = false;
+
   /** Version of `pkg` this deployment currently has pinned in its app-root package.json. */
   public currentVersion(): string | null {
     try {
@@ -170,7 +172,14 @@ export class SelfUpgrade {
    */
   public deliverPendingReport(): UpgradeReport | null {
     const report = this.lastReport();
-    if (!report) return null;
+    if (!report) {
+      // The supervisor writes the report only AFTER this process has booted and soaked, so on a
+      // successful upgrade there is NOTHING here yet — boot always loses the race. Without this
+      // watch the outcome DM was never delivered, and the in-flight marker sat until it aged out
+      // (30m), blocking every retry in between. Keep watching while the marker is live.
+      if (this.inFlight()) this.watchForReport();
+      return null;
+    }
     try { unlinkSync(this.o.reportFile); } catch { /* report already gone; emit anyway */ }
     try { unlinkSync(this.o.lockFile); } catch { /* no lock to clear */ }
 
@@ -178,6 +187,21 @@ export class SelfUpgrade {
     emitEvent('self-upgrade.finished', report);
     return report;
   }
+
+  /** Poll until the supervisor's report lands (or its marker ages out), then deliver it exactly
+   *  once. Unref'd: a pending upgrade watch must never hold the process open. */
+  private watchForReport(): void {
+    if (this.watching) return;
+    this.watching = true;
+    const timer = setInterval(() => {
+      if (!this.inFlight()) { clearInterval(timer); this.watching = false; return; } // aged out
+      if (!existsSync(this.o.reportFile)) return;
+      clearInterval(timer);
+      this.watching = false;
+      this.deliverPendingReport();
+    }, this.o.reportPollMs);
+    timer.unref?.();
+  }
 }
 
 export class SelfUpgradeOptions {
@@ -193,6 +217,8 @@ export class SelfUpgradeOptions {
   public supervisorScript: string = path.join(PACKAGE_ROOT, 'src', 'server', 'self-upgrade', 'supervisor.sh');
   public reportFile: string = dataPath('.self-upgrade', 'report.json');
   public lockFile: string = dataPath('.self-upgrade', 'in-flight.json');
+  /** How often the post-boot watch looks for the supervisor's report. */
+  public reportPollMs: number = 5_000;
   public bootTimeoutSec: number = 180;
   public soakSec: number = 60;
   /** After this, an in-flight marker is treated as abandoned (supervisor killed by a reboot). */