@ddtcorex/dsh-maestro-supervisor 0.5.3 → 0.6.0

package/lib/snapshot.js

@@ -17,12 +17,29 @@ function walkFiles(dir, base = dir) {
     return out;
 }
 export async function writeLKG(dshHome, lkgRoot) {
+    // Dedupe: skip snapshot if current state identical to latest LKG (prevents 5-min unconditional growth)
+    try {
+        if (await isDuplicateLKG(dshHome, lkgRoot)) {
+            const entries = fs.readdirSync(lkgRoot).filter((n) => {
+                try {
+                    return fs.statSync(path.join(lkgRoot, n)).isDirectory();
+                }
+                catch {
+                    return false;
+                }
+            }).sort();
+            const latest = entries[entries.length - 1];
+            const manifestPath = path.join(lkgRoot, latest, 'manifest.json');
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+            return { ts: latest, manifest };
+        }
+    }
+    catch { }
     const ts = new Date().toISOString().replace(/[:.]/g, '-');
     const dest = path.join(lkgRoot, ts);
     fs.mkdirSync(dest, { recursive: true });
-    // Copy DSH home contents (if exists, copy recursively)
+    // Copy DSH home contents (if exists, copy recursively) — skip .supervisor to avoid recursion
     if (fs.existsSync(dshHome)) {
-        // Use cpSync if available
         for (const entry of fs.readdirSync(dshHome)) {
             if (entry === '.supervisor')
                 continue;
@@ -39,8 +56,117 @@ export async function writeLKG(dshHome, lkgRoot) {
             .map(f => ({ path: f, sha256: sha256File(path.join(dest, f)) })),
     };
     fs.writeFileSync(path.join(dest, 'manifest.json'), JSON.stringify(manifest, null, 2));
+    // Retention: keep only 3 most recent, plus age (7d) and size (5GB) caps — prevents unbounded 40GB+ growth
+    await rotateLKG(lkgRoot, 3).catch(() => { });
+    await pruneByAge(lkgRoot, 7 * 24 * 60 * 60 * 1000).catch(() => { });
+    await pruneBySize(lkgRoot, 5 * 1024 * 1024 * 1024).catch(() => { });
     return { ts, manifest };
 }
+export async function pruneByAge(root, maxAgeMs) {
+    if (!fs.existsSync(root))
+        return;
+    const now = Date.now();
+    const entries = fs.readdirSync(root).filter((n) => {
+        try {
+            return fs.statSync(path.join(root, n)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+    for (const name of entries) {
+        try {
+            const tsStr = name.replace(/^(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d+)Z$/, '$1-$2-$3T$4:$5:$6.$7Z');
+            const ts = Date.parse(tsStr);
+            if (!isNaN(ts) && now - ts > maxAgeMs) {
+                fs.rmSync(path.join(root, name), { recursive: true, force: true });
+            }
+        }
+        catch { }
+    }
+}
+export async function pruneBySize(root, maxBytes) {
+    if (!fs.existsSync(root))
+        return;
+    const entries = fs.readdirSync(root).filter((n) => {
+        try {
+            return fs.statSync(path.join(root, n)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }).sort();
+    let total = 0;
+    const sizes = [];
+    for (const name of entries) {
+        try {
+            const p = path.join(root, name);
+            let size = 0;
+            for (const f of walkFiles(p)) {
+                try {
+                    size += fs.statSync(path.join(p, f)).size;
+                }
+                catch { }
+            }
+            sizes.push({ name, size });
+            total += size;
+        }
+        catch { }
+    }
+    for (const { name, size } of sizes) {
+        if (total <= maxBytes)
+            break;
+        try {
+            fs.rmSync(path.join(root, name), { recursive: true, force: true });
+            total -= size;
+        }
+        catch { }
+    }
+}
+export async function isDuplicateLKG(dshHome, lkgRoot) {
+    // Lightweight dedupe: if latest snapshot is <5 minutes old, skip (prevents 5-min unconditional growth)
+    // Full hash check is too heavy (would read 500MB+ each tick) and caused status timeouts
+    if (!fs.existsSync(lkgRoot))
+        return false;
+    const entries = fs.readdirSync(lkgRoot).filter((n) => {
+        try {
+            return fs.statSync(path.join(lkgRoot, n)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }).sort();
+    if (!entries.length)
+        return false;
+    const latestName = entries[entries.length - 1];
+    try {
+        const tsStr = latestName.replace(/^(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d+)Z$/, '$1-$2-$3T$4:$5:$6.$7Z');
+        const ts = Date.parse(tsStr);
+        if (!isNaN(ts) && Date.now() - ts < 5 * 60 * 1000) {
+            // If latest is recent and DSH home hasn't changed in mtime, consider duplicate
+            // Quick check: compare latest snapshot's mtime vs DSH home's newest file mtime
+            const latestPath = path.join(lkgRoot, latestName);
+            const latestMtime = fs.statSync(latestPath).mtimeMs;
+            let newestFileMtime = 0;
+            if (fs.existsSync(dshHome)) {
+                for (const entry of fs.readdirSync(dshHome)) {
+                    if (entry === '.supervisor')
+                        continue;
+                    try {
+                        const s = fs.statSync(path.join(dshHome, entry));
+                        if (s.mtimeMs > newestFileMtime)
+                            newestFileMtime = s.mtimeMs;
+                    }
+                    catch { }
+                }
+            }
+            if (newestFileMtime > 0 && newestFileMtime < latestMtime)
+                return true;
+        }
+    }
+    catch { }
+    return false;
+}
 export async function verifyLKG(lkgPath) {
     const manifestPath = path.join(lkgPath, 'manifest.json');
     if (!fs.existsSync(manifestPath))

package/lib/supervisor.d.ts

@@ -17,6 +17,7 @@ export interface SupervisorDeps {
         gitDiff?: string;
     }) => Promise<string>;
     rollback: (ts?: string) => Promise<void>;
+    restartWeb?: () => Promise<void>;
     notify: (msg: string) => Promise<void>;
     intervalMs?: number;
     debounceMs?: number;
@@ -32,7 +33,13 @@ export interface SupervisorDeps {
         scanned: number;
         interrupted: string[];
     }>;
+    resumeSessions?: (ids: string[]) => Promise<{
+        resumed: string[];
+    }>;
 }
+export declare function resumeViaRpc(ids: string[], fetchFn?: (url: string, init: RequestInit) => Promise<Response>): Promise<{
+    resumed: string[];
+}>;
 export declare class Supervisor {
     private deps;
     private lastRollback;
@@ -43,7 +50,12 @@ export declare class Supervisor {
     constructor(deps: SupervisorDeps);
     private getRunDebugAgent;
     private getFindInterrupted;
+    private getResumeSessions;
+    private getAutoResumeEnabled;
+    private getResumeWithinMs;
+    private findInterruptedRecent;
     private collectGitDiff;
+    private attemptAutoResume;
     private handleDebugResult;
     tick(): Promise<void>;
     start(): void;

package/lib/supervisor.js

@@ -1,5 +1,29 @@
 import { runDebugAgent } from './debug-agent.js';
-import { findInterrupted as defaultFindInterrupted } from './resume.js';
+import { findInterrupted as defaultFindInterrupted, parseDuration } from './resume.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { resolveHarnessRoot } from './paths.js';
+export async function resumeViaRpc(ids, fetchFn = globalThis.fetch) {
+    const rpcId = crypto.randomUUID();
+    const response = await fetchFn('http://127.0.0.1:3080/dsh-maestro-supervisor-resume/resume', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ type: 'client-request', rpcId, method: 'resume', payload: { ids } }),
+    });
+    if (!response.ok)
+        throw new Error(`resume RPC returned HTTP ${response.status}`);
+    const envelope = await response.json();
+    const resumed = envelope?.type === 'server-response'
+        && envelope?.rpcId === rpcId
+        && envelope?.result?.ok === true
+        && Array.isArray(envelope?.result?.value?.resumed)
+        ? envelope.result.value.resumed.filter((id) => typeof id === 'string')
+        : undefined;
+    if (resumed === undefined)
+        throw new Error('resume RPC returned an invalid result');
+    return { resumed };
+}
 export class Supervisor {
     deps;
     lastRollback = 0;
@@ -16,10 +40,141 @@ export class Supervisor {
     getFindInterrupted() {
         return this.deps.findInterrupted ?? defaultFindInterrupted;
     }
+    getResumeSessions() {
+        return this.deps.resumeSessions ?? resumeViaRpc;
+    }
+    getAutoResumeEnabled() {
+        // Priority: env > supervisor config.json > maestro settings.json > default true (enabled)
+        // Configures whether interrupted sessions are auto-resumed after restart (vs only notify).
+        // For Settings UI: boolean toggle — true = auto-resume within window, false = notify only.
+        const env = process.env.DSH_SUPERVISOR_AUTO_RESUME;
+        if (env !== undefined) {
+            const v = env.trim().toLowerCase();
+            if (['1', 'true', 'yes', 'on', 'enabled'].includes(v))
+                return true;
+            if (['0', 'false', 'no', 'off', 'disabled'].includes(v))
+                return false;
+        }
+        try {
+            const cfgPath = path.join(os.homedir(), '.dsh/.supervisor/config.json');
+            if (fs.existsSync(cfgPath)) {
+                const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf-8'));
+                const raw = cfg.autoResumeEnabled ?? cfg.autoResume;
+                if (typeof raw === 'boolean')
+                    return raw;
+                if (typeof raw === 'string') {
+                    const v = raw.trim().toLowerCase();
+                    if (['1', 'true', 'yes', 'on'].includes(v))
+                        return true;
+                    if (['0', 'false', 'no', 'off'].includes(v))
+                        return false;
+                }
+            }
+            const maestroPath = path.join(os.homedir(), '.dsh/maestro/settings.json');
+            if (fs.existsSync(maestroPath)) {
+                const j = JSON.parse(fs.readFileSync(maestroPath, 'utf-8'));
+                const raw = j?.domains?.supervisor?.autoResumeEnabled ?? j?.supervisor?.autoResumeEnabled ?? j?.domains?.supervisor?.autoResume ?? j?.supervisor?.autoResume;
+                if (typeof raw === 'boolean')
+                    return raw;
+                if (typeof raw === 'string') {
+                    const v = raw.trim().toLowerCase();
+                    if (['1', 'true', 'yes', 'on'].includes(v))
+                        return true;
+                    if (['0', 'false', 'no', 'off'].includes(v))
+                        return false;
+                }
+            }
+        }
+        catch { }
+        return true; // default enabled
+    }
+    getResumeWithinMs() {
+        // Priority: env > supervisor config.json > maestro settings.json > default 5 (minutes)
+        // Note: config value is in MINUTES (number 5 = 5 minutes). String "5m"/"30s"/"1h" also supported via parseDuration.
+        const env = process.env.DSH_SUPERVISOR_RESUME_WITHIN;
+        if (env) {
+            // Bare number in env like "5" → treat as minutes for ergonomics
+            if (/^\d+$/.test(env.trim())) {
+                const n = parseInt(env.trim(), 10);
+                if (!isNaN(n))
+                    return n * 60 * 1000;
+            }
+            const v = parseDuration(env);
+            if (v !== undefined)
+                return v;
+            const n = parseInt(env, 10);
+            if (!isNaN(n))
+                return n;
+        }
+        try {
+            const cfgPath = path.join(os.homedir(), '.dsh/.supervisor/config.json');
+            if (fs.existsSync(cfgPath)) {
+                const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf-8'));
+                const raw = cfg.autoResumeWithin ?? cfg.resumeWithin;
+                if (typeof raw === 'string') {
+                    if (/^\d+$/.test(raw.trim()))
+                        return parseInt(raw.trim(), 10) * 60 * 1000; // bare string digits → minutes
+                    const v = parseDuration(raw);
+                    if (v !== undefined)
+                        return v;
+                }
+                else if (typeof raw === 'number')
+                    return raw * 60 * 1000; // number is MINUTES
+            }
+            const maestroPath = path.join(os.homedir(), '.dsh/maestro/settings.json');
+            if (fs.existsSync(maestroPath)) {
+                const j = JSON.parse(fs.readFileSync(maestroPath, 'utf-8'));
+                const raw = j?.domains?.supervisor?.autoResumeWithin ?? j?.supervisor?.autoResumeWithin;
+                if (typeof raw === 'string') {
+                    if (/^\d+$/.test(raw.trim()))
+                        return parseInt(raw.trim(), 10) * 60 * 1000;
+                    const v = parseDuration(raw);
+                    if (v !== undefined)
+                        return v;
+                }
+                else if (typeof raw === 'number')
+                    return raw * 60 * 1000;
+            }
+        }
+        catch { }
+        return 5 * 60 * 1000; // default 5 minutes
+    }
+    async findInterruptedRecent(withinMs) {
+        const ms = withinMs ?? this.getResumeWithinMs();
+        // Prefer injected mock for testability
+        if (this.deps.findInterrupted) {
+            try {
+                const res = await this.deps.findInterrupted();
+                // If mock doesn't filter by time, we still return as-is (test expects all)
+                // For real filtering when mock is not time-aware, try to filter via resume module if possible
+                if (ms !== undefined && res.interrupted.length) {
+                    try {
+                        const { findInterrupted } = await import('./resume.js');
+                        // Re-query with time filter for real filesystem; if mock was used for test, keep mock result
+                        if (process.env.VITEST)
+                            return res;
+                        return findInterrupted(undefined, { withinMs: ms });
+                    }
+                    catch { }
+                }
+                return res;
+            }
+            catch {
+                // fallback to real
+            }
+        }
+        try {
+            const { findInterrupted } = await import('./resume.js');
+            return findInterrupted(undefined, { withinMs: ms });
+        }
+        catch {
+            return this.getFindInterrupted()();
+        }
+    }
     async collectGitDiff() {
         try {
             const { execSync } = await import('node:child_process');
-            const ws = process.env.MAESTRO_HARNESS_ROOT ?? '/home/kai/Work/htdocs/maestro-harness';
+            const ws = resolveHarnessRoot();
             try {
                 const out = execSync(`git -C ${JSON.stringify(ws)} status --porcelain 2>/dev/null | head -n 50`, { encoding: 'utf-8', timeout: 2000 });
                 if (out.trim()) {
@@ -35,13 +190,32 @@ export class Supervisor {
             return '';
         }
     }
+    async attemptAutoResume(ids) {
+        if (!ids.length)
+            return;
+        if (!this.getAutoResumeEnabled()) {
+            await this.deps.notify(`RESUME: ${ids.length} interrupted sessions (${ids.slice(0, 3).join(', ')}) — auto-resume disabled`).catch(() => { });
+            return;
+        }
+        try {
+            const { resumed } = await this.getResumeSessions()(ids);
+            if (!resumed.length) {
+                await this.deps.notify(`RESUME SKIPPED: no interrupted sessions could be re-attached (${ids.slice(0, 3).join(', ')})`).catch(() => { });
+                return;
+            }
+            await this.deps.notify(`RESUME: ${resumed.length} interrupted sessions — continue triggered (${resumed.slice(0, 3).join(', ')})`).catch(() => { });
+        }
+        catch (e) {
+            await this.deps.notify(`RESUME FAILED: ${ids.length} interrupted sessions (${ids.slice(0, 3).join(', ')}) — ${e?.message ?? String(e)}`).catch(() => { });
+        }
+    }
     handleDebugResult(reportPath, res) {
         if (res.fixed) {
             void this.deps.notify(`FIXED: debug-agent fixed ${reportPath} — ${res.reason}`).catch(() => { });
-            // After fix, try to resume interrupted sessions
-            void this.getFindInterrupted()().then(r => {
+            // After fix, try to resume interrupted sessions (only recent, default 5 from config, in minutes)
+            void this.findInterruptedRecent().then(r => {
                 if (r.interrupted.length)
-                    void this.deps.notify(`RESUME: ${r.interrupted.length} interrupted sessions (${r.interrupted.slice(0, 3).join(', ')})`).catch(() => { });
+                    void this.attemptAutoResume(r.interrupted).catch(() => { });
             }).catch(() => { });
         }
         else if (res.reason.includes('max attempts')) {
@@ -71,23 +245,22 @@ export class Supervisor {
                 await this.deps.notify(`DEGRADED: ${health.error ?? 'plugin'} (report: ${reportPath})`).catch(() => { });
                 // Phase 3: debug + resume — use injected fn if provided (even in VITEST), otherwise fire-and-forget real impl (skip in VITEST)
                 const runner = this.getRunDebugAgent();
-                const finder = this.getFindInterrupted();
                 const isInjected = !!this.deps.runDebugAgent;
                 if (isInjected) {
                     void runner({ reportPath, health }).then(res => this.handleDebugResult(reportPath, res)).catch(() => { });
                     setTimeout(() => {
-                        finder().then(r => {
+                        this.findInterruptedRecent().then(r => {
                             if (r.interrupted.length)
-                                this.deps.notify(`RESUME: ${r.interrupted.length} interrupted sessions (${r.interrupted.slice(0, 3).join(', ')})`).catch(() => { });
+                                void this.attemptAutoResume(r.interrupted).catch(() => { });
                         }).catch(() => { });
                     }, 0);
                 }
                 else if (!process.env.VITEST) {
                     void runner({ reportPath, health }).then(res => this.handleDebugResult(reportPath, res)).catch(() => { });
                     setTimeout(() => {
-                        finder().then(r => {
+                        this.findInterruptedRecent().then(r => {
                             if (r.interrupted.length)
-                                this.deps.notify(`RESUME: ${r.interrupted.length} interrupted sessions (${r.interrupted.slice(0, 3).join(', ')})`).catch(() => { });
+                                void this.attemptAutoResume(r.interrupted).catch(() => { });
                         }).catch(() => { });
                     }, 0);
                 }
@@ -124,26 +297,40 @@ export class Supervisor {
             const logTail = health.logTail ?? '';
             const gitDiff = await this.collectGitDiff().catch(() => '');
             const reportPath = await this.deps.writeReport({ ts, health, action: `rollback — ${health.error ?? 'down'}`, logTail, gitDiff }).catch(() => '');
-            await this.deps.rollback();
+            try {
+                await this.deps.rollback();
+            }
+            catch (e) {
+                await this.deps.notify(`rollback failed: ${e?.message ?? String(e)} (report: ${reportPath})`).catch(() => { });
+            }
+            // Always attempt to (re)start dsh web — survives reboot even when rollback is a no-op
+            if (this.deps.restartWeb) {
+                try {
+                    await this.deps.restartWeb();
+                    await this.deps.notify(`restarted dsh-web after rollback (report: ${reportPath})`).catch(() => { });
+                }
+                catch (e) {
+                    await this.deps.notify(`restart dsh-web failed: ${e?.message ?? String(e)} (report: ${reportPath})`).catch(() => { });
+                }
+            }
             await this.deps.notify(`CRASH detected → rollback (report: ${reportPath}, error: ${health.error ?? 'down'})`).catch(() => { });
             const runner = this.getRunDebugAgent();
-            const finder = this.getFindInterrupted();
             const isInjected = !!this.deps.runDebugAgent;
             if (isInjected) {
                 void runner({ reportPath, health }).then(res => this.handleDebugResult(reportPath, res)).catch(() => { });
                 setTimeout(() => {
-                    finder().then(r => {
+                    this.findInterruptedRecent().then(r => {
                         if (r.interrupted.length)
-                            this.deps.notify(`RESUME: ${r.interrupted.length} interrupted sessions`).catch(() => { });
+                            void this.attemptAutoResume(r.interrupted).catch(() => { });
                     }).catch(() => { });
                 }, 0);
             }
             else if (!process.env.VITEST) {
                 void runner({ reportPath, health }).then(res => this.handleDebugResult(reportPath, res)).catch(() => { });
                 setTimeout(() => {
-                    finder().then(r => {
+                    this.findInterruptedRecent().then(r => {
                         if (r.interrupted.length)
-                            this.deps.notify(`RESUME: ${r.interrupted.length} interrupted sessions`).catch(() => { });
+                            void this.attemptAutoResume(r.interrupted).catch(() => { });
                     }).catch(() => { });
                 }, 0);
             }
@@ -157,6 +344,8 @@ export class Supervisor {
             return;
         const intervalMs = this.deps.intervalMs ?? 3000;
         this.timer = setInterval(() => { this.tick().catch(() => { }); }, intervalMs);
+        // Immediate tick so a reboot is recovered in ~0-3s, not 3s
+        this.tick().catch(() => { });
     }
     stop() {
         if (this.timer) {

package/lib/types/client/auto-reload.d.ts

@@ -0,0 +1,8 @@
+/**
+ * dsh-maestro-supervisor — client auto-reload for DSH Web after restart.
+ * Hybrid: polls `HEAD /` when the server is down (offline/WebSocket close)
+ * and reloads as soon as it is back. The host also pushes a reload via
+ * `POST /dsh-maestro-supervisor-reload` (loopback) when it recovers.
+ */
+export declare function apply(ctx: any): void;
+//# sourceMappingURL=auto-reload.d.ts.map

package/lib/types/client/auto-reload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-reload.d.ts","sourceRoot":"","sources":["../../../src/client/auto-reload.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,wBAAgB,KAAK,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CA4FpC"}

package/lib/types/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from './auto-reload.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA"}

package/package.json

@@ -1,14 +1,40 @@
 {
   "name": "@ddtcorex/dsh-maestro-supervisor",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "Supervisor daemon for DSH Web resilience — auto-detect crashes, rollback to LKG, report",
   "type": "module",
+  "main": "./lib/index.js",
+  "types": "./lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/auto-reload.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
   "bin": {
-    "dsh-web-supervisor": "./lib/index.js"
+    "dsh-web-supervisor": "./lib/bin.js"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime"
+      ]
+    }
   },
   "files": [
     "lib",
-    "README.md"
+    "README.md",
+    "cordis.patch.yml"
   ],
   "devDependencies": {
     "@types/node": "^26.3.0",
@@ -16,8 +42,8 @@
     "vitest": "^3.2.4"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "verify": "tsc --noEmit",
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.client.json && node scripts/build-client.mjs",
+    "verify": "tsc --noEmit && tsc -p tsconfig.client.json --noEmit",
     "test": "vitest run",
     "test:watch": "vitest"
   }