@ddtcorex/dsh-maestro-supervisor 0.1.0 → 0.3.0

package/lib/debug-agent.d.ts

@@ -0,0 +1,14 @@
+export interface DebugAgentOpts {
+    reportPath: string;
+    health: {
+        error?: string;
+        httpCode?: number;
+    };
+    attempts?: number;
+    cooldownMs?: number;
+}
+export declare function runDebugAgent(opts: DebugAgentOpts): Promise<{
+    fixed: boolean;
+    reason: string;
+}>;
+export declare function _resetDebugAgentForTest(): void;

package/lib/debug-agent.js

@@ -0,0 +1,23 @@
+let lastRun = 0;
+let attempts = 0;
+const MAX_ATTEMPTS = 3;
+export async function runDebugAgent(opts) {
+    const now = Date.now();
+    const cooldownMs = opts.cooldownMs ?? 10 * 60 * 1000;
+    if (now - lastRun < cooldownMs) {
+        return { fixed: false, reason: 'cooldown' };
+    }
+    if (attempts >= MAX_ATTEMPTS) {
+        return { fixed: false, reason: 'max attempts' };
+    }
+    lastRun = now;
+    attempts++;
+    // Stub: Phase 3 full LLM wiring will use systematic-debugging preset
+    // For now just log and return not fixed — supervisor will still resume sessions
+    // Real implementation: spawn subagent via @ddtcorex/dsh-maestro-notifier or openai
+    return { fixed: false, reason: `stub — would debug ${opts.reportPath} (attempt ${attempts})` };
+}
+export function _resetDebugAgentForTest() {
+    lastRun = 0;
+    attempts = 0;
+}

package/lib/health-poller.js

@@ -46,13 +46,30 @@ export async function pollHealth(opts = {}) {
             break;
         }
     }
-    // If either fetch failed or log has error, consider down
-    if (fetchError || logError) {
+    // Distinguish FULL (http !=200) vs DEGRADED (http 200 but log has plugin error)
+    if (fetchError) {
         return {
             up: false,
             httpCode,
-            error: logError ?? fetchError,
-            degraded: !!logError && httpCode === 200,
+            error: logError ? `${fetchError} + ${logError}` : fetchError,
+            degraded: false,
+        };
+    }
+    if (logError) {
+        // http 200 but log error → DEGRADED (isolatable), not FULL
+        if (httpCode === 200) {
+            return {
+                up: true,
+                httpCode,
+                error: logError,
+                degraded: true,
+            };
+        }
+        return {
+            up: false,
+            httpCode,
+            error: logError,
+            degraded: false,
         };
     }
     // Also check psAlive as secondary signal — if fetch ok but ps dead, still down
@@ -95,9 +112,16 @@ async function defaultLogTail() {
     try {
         const { readFileSync } = await import('node:fs');
         const { homedir } = await import('node:os');
-        const logPath = `${homedir()}/.dsh.log`;
-        const content = readFileSync(logPath, 'utf-8');
-        return content.slice(-5000);
+        const candidates = [`${homedir()}/.dsh/dsh-web.log`, `${homedir()}/.dsh.log`];
+        for (const logPath of candidates) {
+            try {
+                const content = readFileSync(logPath, 'utf-8');
+                if (content)
+                    return content.slice(-5000);
+            }
+            catch { }
+        }
+        return '';
     }
     catch {
         return '';

package/lib/resume.d.ts

@@ -0,0 +1,5 @@
+export interface ResumeResult {
+    scanned: number;
+    interrupted: string[];
+}
+export declare function findInterrupted(dshHome?: string): Promise<ResumeResult>;

package/lib/resume.js

@@ -0,0 +1,41 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+export async function findInterrupted(dshHome) {
+    const home = dshHome ?? path.join(os.homedir(), '.dsh');
+    const sessionsRoot = path.join(home, 'sessions');
+    let scanned = 0;
+    const interrupted = [];
+    try {
+        const groups = fs.readdirSync(sessionsRoot, { withFileTypes: true });
+        for (const g of groups) {
+            if (!g.isDirectory())
+                continue;
+            const groupPath = path.join(sessionsRoot, g.name);
+            const sessions = fs.readdirSync(groupPath, { withFileTypes: true });
+            for (const s of sessions) {
+                if (!s.isDirectory())
+                    continue;
+                scanned++;
+                const zstdPath = path.join(groupPath, s.name, 'session.jsonl.zstd');
+                const jsonlPath = path.join(groupPath, s.name, 'session.jsonl');
+                try {
+                    let content = '';
+                    if (fs.existsSync(zstdPath)) {
+                        const { execSync } = await import('node:child_process');
+                        content = execSync(`zstd -d -c ${JSON.stringify(zstdPath)} 2>/dev/null | tail -5`, { encoding: 'utf-8' });
+                    }
+                    else if (fs.existsSync(jsonlPath)) {
+                        content = fs.readFileSync(jsonlPath, 'utf-8').slice(-5000);
+                    }
+                    if (content.toLowerCase().includes('interrupted')) {
+                        interrupted.push(`${g.name}/${s.name}`);
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+    return { scanned, interrupted };
+}

package/lib/supervisor.d.ts

@@ -25,6 +25,7 @@ export declare class Supervisor {
     private lastRollback;
     private rollingBack;
     private lastLKGWrite;
+    private lastDegradedNotify;
     private timer;
     constructor(deps: SupervisorDeps);
     tick(): Promise<void>;

package/lib/supervisor.js

@@ -1,14 +1,41 @@
+import { runDebugAgent } from './debug-agent.js';
+import { findInterrupted } from './resume.js';
 export class Supervisor {
     deps;
     lastRollback = 0;
     rollingBack = false;
     lastLKGWrite = 0;
+    lastDegradedNotify = 0;
     timer = null;
     constructor(deps) {
         this.deps = deps;
     }
     async tick() {
         const health = await this.deps.pollHealth();
+        // DEGRADED: http 200 but log has plugin error → report, notify, no rollback
+        if (health.degraded) {
+            const now = this.deps.getTime ? this.deps.getTime() : Date.now();
+            if (now - this.lastDegradedNotify < 60000)
+                return;
+            this.lastDegradedNotify = now;
+            try {
+                const ts = new Date().toISOString().replace(/[:.]/g, '-');
+                const reportPath = await this.deps.writeReport({ ts, health, action: `degraded — ${health.error ?? 'plugin'}` }).catch(() => '');
+                await this.deps.notify(`DEGRADED: ${health.error ?? 'plugin'} (report: ${reportPath})`).catch(() => { });
+                // Phase 3: fire-and-forget debug + resume (never block tick, skip in test)
+                if (!process.env.VITEST) {
+                    void runDebugAgent({ reportPath, health }).catch(() => { });
+                    setTimeout(() => {
+                        findInterrupted().then(r => {
+                            if (r.interrupted.length)
+                                this.deps.notify(`RESUME: ${r.interrupted.length} interrupted sessions (${r.interrupted.slice(0, 3).join(', ')})`).catch(() => { });
+                        }).catch(() => { });
+                    }, 0);
+                }
+            }
+            catch { }
+            return;
+        }
         if (health.up) {
             // Throttle LKG writes to at most once per 5 minutes
             const now = this.deps.getTime ? this.deps.getTime() : Date.now();
@@ -38,6 +65,15 @@ export class Supervisor {
             const reportPath = await this.deps.writeReport({ ts, health, action: `rollback — ${health.error ?? 'down'}` }).catch(() => '');
             await this.deps.rollback();
             await this.deps.notify(`CRASH detected → rollback (report: ${reportPath}, error: ${health.error ?? 'down'})`).catch(() => { });
+            if (!process.env.VITEST) {
+                void runDebugAgent({ reportPath, health }).catch(() => { });
+                setTimeout(() => {
+                    findInterrupted().then(r => {
+                        if (r.interrupted.length)
+                            this.deps.notify(`RESUME: ${r.interrupted.length} interrupted sessions`).catch(() => { });
+                    }).catch(() => { });
+                }, 0);
+            }
         }
         finally {
             this.rollingBack = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ddtcorex/dsh-maestro-supervisor",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Supervisor daemon for DSH Web resilience — auto-detect crashes, rollback to LKG, report",
   "type": "module",
   "bin": {