shraga 0.1.49 → 0.1.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shraga",
-  "version": "0.1.49",
+  "version": "0.1.51",
   "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

@@ -1,8 +1,8 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync } from 'node:fs';
+import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { hostname } from 'node:os';
 import { DATA_DIR } from './paths.ts';
-import { emitEvent } from './events/bus.ts';
+import { notifyOwners } from './notify-owners.ts';
 import { runTextQuery } from './sdk-utils.ts';
 
 const TAG = '[data-sync]';
@@ -116,10 +116,12 @@ export class DataSync {
     // Defer heavy sync I/O (reads all tracked files + execSync) to avoid blocking
     // WS connections and page loads during startup.
     setTimeout(() => {
-      this.scanForConflictMarkers().catch(err => {
-        console.warn(`${TAG} Post-init conflict scan failed:`, (err as Error).message);
-      });
-      this.runIntegrityAudit();
+      this.scanForConflictMarkers()
+        .catch(err => console.warn(`${TAG} Post-init conflict scan failed:`, (err as Error).message))
+        // execSync inside the audit blocks too — keep it off the scan's tick so the two
+        // never add up into one long freeze.
+        .then(() => new Promise<void>(r => setImmediate(r)))
+        .then(() => this.runIntegrityAudit());
     }, 60_000);
   }
 
@@ -442,13 +444,20 @@ export class DataSync {
     try {
       const tracked = (await this.git('ls-files')).split('\n').filter(Boolean);
       const conflicted: string[] = [];
-      for (const f of tracked) {
-        const abs = path.join(DATA_DIR, f);
+      // ASYNC + YIELDING on purpose. This walks every tracked file (1000+, GBs on a real
+      // deployment); doing it synchronously froze the event loop for ~45s — the server stopped
+      // answering /api/version entirely, which also made self-upgrade verification fail and
+      // auto-revert healthy versions. Deferring a synchronous freeze only moves it; it has to
+      // not block at all.
+      for (let i = 0; i < tracked.length; i++) {
+        const abs = path.join(DATA_DIR, tracked[i]);
         try {
-          if (!existsSync(abs) || statSync(abs).isDirectory()) continue;
-          const content = readFileSync(abs, 'utf-8');
-          if (/^<{7} /m.test(content)) conflicted.push(f);
+          const info = await stat(abs).catch(() => null);
+          if (!info || info.isDirectory()) continue;
+          const content = await readFile(abs, 'utf-8');
+          if (/^<{7} /m.test(content)) conflicted.push(tracked[i]);
         } catch { /* skip unreadable */ }
+        if (i % 25 === 24) await new Promise<void>(r => setImmediate(r)); // let the server breathe
       }
       if (!conflicted.length) return;
 
@@ -566,24 +575,10 @@ export class DataSync {
       console.warn(`${TAG} notification suppressed (not the authoritative instance):\n${text}`);
       return;
     }
-    // No Slack coupling here — resolve owner contacts and publish a deploy notice on the event bus.
-    // The Slack feature (slackFeature) subscribes and DMs each owner. Owner resolution uses the
-    // contacts store only, so data-sync stays transport-agnostic.
-    const { getAll } = await import('./contacts.ts');
-    const ownerEmails = (process.env.OWNERS ?? '').split(',').map(s => s.trim().toLowerCase()).filter(Boolean);
-    const owners = getAll()
-      .filter(c => c.slackIds.length > 0 && c.emails.some(e => ownerEmails.includes(e.toLowerCase())))
-      .map(c => ({ name: c.name, slackId: c.slackIds[0] }));
-    if (!owners.length) {
-      console.warn(`${TAG} No owners (OWNERS env) with Slack IDs found, skipping notification`);
-      return;
-    }
-    // Stamp the sender: every owner alert must name the instance it came from, so "is this back?"
-    // is answerable without log archaeology across hosts.
-    const from = `${this.options.deploymentId || 'shraga'}@${hostname()}`;
-    emitEvent('data-sync', { kind: 'deploy', owners, text: `${text}\n\n_from ${from}_` });
+    await notifyOwners('data-sync', text);
   }
 
+
   /**
    * Routed through the Claude Code SDK (runTextQuery), same as the rest of the platform —
    * authenticates via the CC subscription, no ANTHROPIC_API_KEY required. Past incident:

package/src/server/notify-owners.ts

@@ -0,0 +1,41 @@
+// Reaching a human, transport-agnostically. Resolve the deployment's owners from the contacts
+// store and publish a "deploy notice" on the event bus; the Slack feature subscribes and DMs each
+// one. Callers stay free of Slack (and of owner-resolution) entirely.
+//
+// This lives on its own because more than one subsystem needs it — data-sync's merge/integrity
+// alerts and self-upgrade's outcome report — and the second one silently had NO delivery at all:
+// it emitted an event nobody subscribed to, so a finished upgrade never reached anyone.
+import { hostname } from 'node:os';
+import { emitEvent } from './events/bus.ts';
+
+export type Owner = { name?: string; slackId: string };
+
+/** Owners of THIS deployment (OWNERS env ∩ contacts that have a Slack id). */
+export async function resolveOwners(): Promise<Owner[]> {
+  const { getAll } = await import('./contacts.ts');
+  const ownerEmails = (process.env.OWNERS ?? '').split(',').map(s => s.trim().toLowerCase()).filter(Boolean);
+  return getAll()
+    .filter(c => c.slackIds.length > 0 && c.emails.some(e => ownerEmails.includes(e.toLowerCase())))
+    .map(c => ({ name: c.name, slackId: c.slackIds[0] }));
+}
+
+/** `APP_NAME@host` — every owner-facing alert names the instance it came from, so "is this back?"
+ *  is answerable without log archaeology across hosts. */
+export function senderStamp(): string {
+  return `${process.env.APP_NAME || 'shraga'}@${hostname()}`;
+}
+
+/**
+ * DM the owners. `source` is the event-bus source (used for logging/filtering only) — delivery is
+ * keyed on the notice `kind`, so a new subsystem needs no change on the Slack side.
+ * Returns false when there was nobody to tell.
+ */
+export async function notifyOwners(source: string, text: string): Promise<boolean> {
+  const owners = await resolveOwners();
+  if (!owners.length) {
+    console.warn(`[${source}] No owners (OWNERS env) with Slack IDs found, skipping notification`);
+    return false;
+  }
+  emitEvent(source as any, { kind: 'deploy', owners, text: `${text}\n\n_from ${senderStamp()}_` });
+  return true;
+}

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

@@ -14,6 +14,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { APP_ROOT, PACKAGE_ROOT, dataPath } from '../paths.ts';
 import { emitEvent } from '../events/bus.ts';
+import { notifyOwners } from '../notify-owners.ts';
 
 const TAG = '[self-upgrade]';
 const PKG = 'shraga';
@@ -191,6 +192,12 @@ export class SelfUpgrade {
 
     console.log(`${TAG} ${report.status}: ${report.detail}`);
     emitEvent('self-upgrade.finished', report);
+    // ...and actually tell a human. The event alone reached nobody: no subscriber existed, so every
+    // upgrade outcome — including `revert-failed`, which needs hands — was silently dropped.
+    const icon = report.status === 'ok' ? '✅' : report.status === 'reverted' ? '↩️' : '🚨';
+    notifyOwners('self-upgrade', `${icon} Self-upgrade ${report.status}: ${report.detail}\n\n` +
+      `${report.package} ${report.from} → ${report.target} (now on ${report.installed})\nLog: \`${report.log}\``)
+      .catch(err => console.warn(`${TAG} could not notify owners:`, (err as Error).message));
     return report;
   }
 

package/src/server/slack/feature.ts

@@ -25,11 +25,12 @@ export const slackFeature: ServerFeature = {
 
     if (!oauthMounted) { oauthMounted = true; registerSlackOAuthRoutes(ctx.app); }
 
-    // Data-sync deploy notices arrive on the event bus (data-sync.ts has no Slack coupling); DM owners.
+    // Owner notices arrive on the event bus (see notify-owners.ts — no subsystem couples to Slack);
+    // DM owners. Keyed on the notice KIND, not the source: self-upgrade emitted its outcome under
+    // its own source and a source-gated subscriber silently dropped every one of them.
     if (!ctx.passive && !busSubscribed) {
       busSubscribed = true;
       subscribeEvents((evt) => {
-        if (evt.source !== 'data-sync') return;
         const payload = evt.payload as DeployNotice;
         if (payload?.kind !== 'deploy' || !payload.owners?.length) return;
         for (const owner of payload.owners) {