@ddtcorex/dsh-maestro-supervisor 0.2.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/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.js

@@ -1,3 +1,5 @@
+import { runDebugAgent } from './debug-agent.js';
+import { findInterrupted } from './resume.js';
 export class Supervisor {
     deps;
     lastRollback = 0;
@@ -20,6 +22,16 @@ export class Supervisor {
                 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;
@@ -53,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.2.0",
+  "version": "0.3.0",
   "description": "Supervisor daemon for DSH Web resilience — auto-detect crashes, rollback to LKG, report",
   "type": "module",
   "bin": {