@ddtcorex/dsh-maestro-supervisor 0.2.0 → 0.4.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,66 @@
+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++;
+    // Phase 3A: deterministic checks before LLM
+    // 1) Try pnpm verify in the degraded package (if identifiable)
+    // 2) Dry-boot DSH web on ephemeral port
+    // If both pass, consider fixed (degraded was transient, e.g. log tail stale)
+    // Otherwise, would spawn systematic-debugging subagent (LLM) — stub for now
+    try {
+        const { execSync } = await import('node:child_process');
+        const { readFileSync } = await import('node:fs');
+        // Check report exists
+        let report = '';
+        try {
+            report = readFileSync(opts.reportPath, 'utf-8');
+        }
+        catch { }
+        // If error is ERR_MODULE_NOT_FOUND for a package that now has lib/index.js, consider fixed
+        const err = opts.health.error ?? '';
+        if (err.includes('ERR_MODULE_NOT_FOUND') || err.includes('Cannot find module')) {
+            // Check if the missing file now exists (e.g. after pnpm build)
+            // This is a heuristic: if any dsh-maestro package now has lib/index.js, the degraded may be stale
+            const candidates = ['dsh-maestro-supervisor', 'dsh-maestro-observe', 'dsh-maestro-memory'];
+            for (const pkg of candidates) {
+                try {
+                    const p = `/home/kai/Work/htdocs/maestro-harness/packages/${pkg}/lib/index.js`;
+                    readFileSync(p);
+                    // if file exists, the error may be transient — try verify
+                    try {
+                        execSync(`pnpm --dir /home/kai/Work/htdocs/maestro-harness/packages/${pkg} verify --silent 2>&1 | head -5`, { timeout: 15000 });
+                    }
+                    catch { }
+                }
+                catch { }
+            }
+        }
+        // Dry-boot check (isolated DSH_HOME, port 0)
+        try {
+            const tmp = execSync('mktemp -d', { encoding: 'utf-8' }).trim();
+            const port = Math.floor(19000 + Math.random() * 1000);
+            const out = execSync(`timeout 8 bash -c 'DSH_HOME=${tmp} pnpm --dir /home/kai/Work/htdocs/maestro-harness/deepseek-harness dsh web --port ${port} --no-open >${tmp}/dsh.log 2>&1 & pid=\\$!; for i in \\$(seq 1 5); do sleep 1; if curl -s -o /dev/null -w "%{http_code}" http://127.0.0.1:${port}/ 2>&1 | grep -q 200; then kill \\$pid 2>/dev/null || true; wait \\$pid 2>/dev/null || true; echo ok; exit 0; fi; done; kill \\$pid 2>/dev/null || true; wait \\$pid 2>/dev/null || true; echo fail; exit 1'`, { encoding: 'utf-8', timeout: 12000 });
+            execSync(`rm -rf ${tmp}`);
+            if (out.includes('ok')) {
+                return { fixed: true, reason: `dry-boot ok (attempt ${attempts}) — transient degraded` };
+            }
+        }
+        catch { }
+    }
+    catch { }
+    return { fixed: false, reason: `would debug ${opts.reportPath} (attempt ${attempts}) — LLM not wired, manual fix needed` };
+}
+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.4.0",
   "description": "Supervisor daemon for DSH Web resilience — auto-detect crashes, rollback to LKG, report",
   "type": "module",
   "bin": {