@ddtcorex/dsh-maestro-supervisor 0.5.3 → 0.6.0

package/lib/plugin.d.ts

@@ -0,0 +1,42 @@
+/**
+ * dsh-maestro-supervisor — host plugin for auto-resume inside DSH web.
+ * Runs inside the DSH host process (outside the daemon's tree) and
+ * auto-resumes sessions interrupted within the configured window after
+ * a restart. The standalone daemon (systemd) handles crash detection
+ * and web restart; this plugin handles the in-process resume.
+ */
+import { findInterrupted as defaultFindInterrupted, findDanglingOpenTurns as defaultFindDanglingOpenTurns } from './resume.js';
+export declare const inject: readonly ["sessions", "agents", "connection"];
+export interface SupervisorPluginConfig {
+    autoResumeWithin?: number | string;
+    autoResumeEnabled?: boolean;
+}
+export declare function runAutoResume(ctx: any, opts?: {
+    findInterrupted?: typeof defaultFindInterrupted;
+    findDanglingOpenTurns?: typeof defaultFindDanglingOpenTurns;
+    resumeInterrupted?: typeof resumeInterrupted;
+    config?: SupervisorPluginConfig;
+}): Promise<void>;
+export declare function resumeInterrupted(ctx: any, ids: string[]): Promise<string[]>;
+export declare function createResumeRpcHandler(ctx: any, opts?: {
+    resumeInterrupted?: typeof resumeInterrupted;
+    config?: SupervisorPluginConfig;
+}): (endpoint: string, payload: unknown, _signal: AbortSignal) => Promise<{
+    ok: boolean;
+    value: import("./resume.js").ResumeResult;
+    error?: undefined;
+} | {
+    ok: boolean;
+    error: {
+        code: string;
+        message: string;
+    };
+    value?: undefined;
+} | {
+    ok: boolean;
+    value: {
+        resumed: string[];
+    };
+    error?: undefined;
+}>;
+export declare function apply(ctx: any, config?: SupervisorPluginConfig): void;

package/lib/plugin.js

@@ -0,0 +1,290 @@
+/**
+ * dsh-maestro-supervisor — host plugin for auto-resume inside DSH web.
+ * Runs inside the DSH host process (outside the daemon's tree) and
+ * auto-resumes sessions interrupted within the configured window after
+ * a restart. The standalone daemon (systemd) handles crash detection
+ * and web restart; this plugin handles the in-process resume.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { findInterrupted as defaultFindInterrupted, findDanglingOpenTurns as defaultFindDanglingOpenTurns } from './resume.js';
+export const inject = ['sessions', 'agents', 'connection'];
+function parseDuration(s) {
+    if (!s)
+        return undefined;
+    const m = s.trim().match(/^(\d+)(s|m|h)?$/);
+    if (!m)
+        return undefined;
+    const n = parseInt(m[1], 10);
+    const unit = m[2] ?? 's';
+    if (unit === 's')
+        return n * 1000;
+    if (unit === 'm')
+        return n * 60 * 1000;
+    if (unit === 'h')
+        return n * 60 * 60 * 1000;
+    return undefined;
+}
+function getAutoResumeEnabled(config) {
+    // The Cordis-supplied config (cordis.patch.yml's `config:` block, or whatever
+    // the caller passes to apply()) is the highest-precedence source — it is an
+    // explicit, per-install decision and must win over ambient env/files.
+    if (typeof config?.autoResumeEnabled === 'boolean')
+        return config.autoResumeEnabled;
+    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;
+            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;
+}
+function getResumeWithinMs(config) {
+    // Same precedence rule as getAutoResumeEnabled: explicit config wins first.
+    if (config?.autoResumeWithin !== undefined) {
+        const raw = config.autoResumeWithin;
+        if (typeof raw === 'number')
+            return raw * 60 * 1000;
+        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;
+        }
+    }
+    const env = process.env.DSH_SUPERVISOR_RESUME_WITHIN;
+    if (env) {
+        if (/^\d+$/.test(env.trim()))
+            return parseInt(env.trim(), 10) * 60 * 1000;
+        const v = parseDuration(env);
+        if (v !== undefined)
+            return v;
+    }
+    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;
+            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;
+        }
+        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;
+}
+export async function runAutoResume(ctx, opts = {}) {
+    try {
+        const doFind = opts.findInterrupted ?? defaultFindInterrupted;
+        const doFindDangling = opts.findDanglingOpenTurns ?? defaultFindDanglingOpenTurns;
+        const doResume = opts.resumeInterrupted ?? resumeInterrupted;
+        if (!getAutoResumeEnabled(opts?.config)) {
+            ctx.logger?.info?.('[supervisor] auto-resume disabled — skip');
+            return;
+        }
+        const withinMs = getResumeWithinMs(opts?.config);
+        const { scanned, interrupted } = await doFind(undefined, { withinMs });
+        // Only safe to treat a dangling open turn as crashed right after a fresh
+        // boot, when this process is the sole live owner of these sessions —
+        // exactly the context runAutoResume runs in (called once, 8s after
+        // apply()). resumeInterrupted()'s own "already live" check additionally
+        // protects any id that happens to be live in *this* process already.
+        let dangling = [];
+        try {
+            dangling = (await doFindDangling(undefined, { withinMs })).interrupted;
+        }
+        catch (e) {
+            ctx.logger?.warn?.(`[supervisor] auto-resume: dangling-open-turn scan failed, continuing with closed-turn results only: ${e?.message ?? String(e)}`);
+        }
+        const merged = Array.from(new Set([...interrupted, ...dangling]));
+        if (!merged.length) {
+            ctx.logger?.info?.(`[supervisor] auto-resume: 0/${scanned} interrupted within ${withinMs}ms — nothing to do`);
+            return;
+        }
+        ctx.logger?.info?.(`[supervisor] auto-resume: ${merged.length}/${scanned} interrupted within ${withinMs}ms: ${merged.slice(0, 3).join(', ')}`);
+        await doResume(ctx, merged);
+    }
+    catch (e) {
+        try {
+            ctx.logger?.warn?.(`[supervisor] auto-resume error: ${e?.message ?? String(e)}`);
+        }
+        catch { }
+    }
+}
+export async function resumeInterrupted(ctx, ids) {
+    const resumed = [];
+    for (const id of ids) {
+        try {
+            const sessionId = id.split('/').pop();
+            const agents = ctx.get?.('agents') ?? ctx.agents;
+            let agent = agents?.get?.(sessionId);
+            if (agent === undefined) {
+                const { SessionId } = await import('@deepseek-ai/dsh-session').catch(() => ({ SessionId: (s) => s }));
+                const sid = SessionId ? SessionId(sessionId) : sessionId;
+                const persistence = ctx.get?.('sessionPersistence') ?? ctx.sessionPersistence;
+                let agentOptions;
+                try {
+                    const loaded = await persistence?.load?.(sessionId);
+                    const context = Array.isArray(loaded?.events)
+                        ? [...loaded.events].reverse().find((event) => event?.type === 'request/context')?.data
+                        : undefined;
+                    if (typeof context?.provider === 'string' && typeof context?.model === 'string') {
+                        agentOptions = { provider: context.provider, model: context.model };
+                    }
+                }
+                catch (e) {
+                    ctx.logger?.warn?.(`[supervisor] auto-resume: could not recover route for ${id}: ${e?.message ?? String(e)}`);
+                }
+                const handle = await agents?.resume?.({
+                    resumeSessionId: sid,
+                    ...(agentOptions === undefined ? {} : { agentOptions }),
+                });
+                agent = handle?.agent;
+                if (agent !== undefined)
+                    ctx.logger?.info?.(`[supervisor] auto-resume: re-attached agent for ${id}`);
+            }
+            if (typeof agent?.followup !== 'function') {
+                ctx.logger?.warn?.(`[supervisor] auto-resume: no live agent available for ${id}`);
+                continue;
+            }
+            const { createUserMessage } = await import('@deepseek-ai/dsh-llm').catch(() => ({
+                createUserMessage: (input) => ({ ...input, role: 'user', id: crypto.randomUUID() }),
+            }));
+            agent.followup(createUserMessage({
+                content: [{ type: 'text', text: 'continue' }],
+                source: { kind: 'user' },
+            }));
+            resumed.push(id);
+            ctx.logger?.info?.(`[supervisor] auto-resume: sent continue trigger for ${id}`);
+        }
+        catch (e) {
+            ctx.logger?.warn?.(`[supervisor] auto-resume failed ${id}: ${e?.message ?? String(e)}`);
+        }
+    }
+    return resumed;
+}
+export function createResumeRpcHandler(ctx, opts = {}) {
+    const resume = opts.resumeInterrupted ?? resumeInterrupted;
+    return async (endpoint, payload, _signal) => {
+        if (endpoint === 'scan') {
+            const withinMs = typeof payload?.withinMs === 'number'
+                ? payload.withinMs
+                : getResumeWithinMs(opts.config);
+            return { ok: true, value: await defaultFindInterrupted(undefined, { withinMs }) };
+        }
+        if (endpoint !== 'resume') {
+            return { ok: false, error: { code: 'bad-request', message: `unsupported endpoint: ${endpoint}` } };
+        }
+        const ids = Array.isArray(payload?.ids)
+            ? payload.ids.filter((id) => typeof id === 'string' && id.length > 0)
+            : [];
+        if (!ids.length) {
+            return { ok: false, error: { code: 'bad-request', message: 'resume requires at least one session id' } };
+        }
+        return { ok: true, value: { resumed: await resume(ctx, ids) } };
+    };
+}
+export function apply(ctx, config = {}) {
+    // The whole body is wrapped: per AGENTS.md, apply() must never throw
+    // synchronously or let a rejected promise escape, no matter what fails
+    // (ctx.effect missing/throwing, RPC registration throwing, or even the
+    // error-reporting logger call itself throwing).
+    try {
+        ctx.effect(() => {
+            let disposed = false;
+            let timer = null;
+            timer = setTimeout(() => {
+                if (disposed)
+                    return;
+                runAutoResume(ctx, { config }).catch(() => {
+                    // runAutoResume already never rejects, but guard the .catch itself is a no-op safety net
+                });
+            }, 8000);
+            let disposeRpc;
+            try {
+                const conn = ctx.connection ?? ctx.get?.('connection');
+                if (conn?.rpc?.handle) {
+                    disposeRpc = conn.rpc.handle('/dsh-maestro-supervisor-resume', createResumeRpcHandler(ctx, { config }), { authority: 'loopback' });
+                }
+            }
+            catch (e) {
+                try {
+                    ctx.logger?.warn?.(`[supervisor] auto-resume RPC registration failed: ${e?.message ?? String(e)}`);
+                }
+                catch { }
+            }
+            return () => {
+                disposed = true;
+                if (timer)
+                    clearTimeout(timer);
+                if (disposeRpc) {
+                    try {
+                        disposeRpc();
+                    }
+                    catch { }
+                }
+            };
+        }, 'supervisor:auto-resume');
+    }
+    catch (e) {
+        try {
+            ctx.logger?.warn?.(`[supervisor] auto-resume apply() failed: ${e?.message ?? String(e)}`);
+        }
+        catch { }
+    }
+}

package/lib/resume.d.ts

@@ -2,4 +2,23 @@ export interface ResumeResult {
     scanned: number;
     interrupted: string[];
 }
-export declare function findInterrupted(dshHome?: string): Promise<ResumeResult>;
+export interface FindInterruptedOpts {
+    withinMs?: number;
+    sinceMs?: number;
+}
+export declare function findInterrupted(dshHome?: string, opts?: FindInterruptedOpts): Promise<ResumeResult>;
+/**
+ * Detect sessions whose raw log ends with a `turn/start` that has no
+ * matching `turn/end` anywhere later in the scanned log — a dangling open
+ * turn. Unlike {@link findInterrupted}, this needs no prior `persistence.load()`
+ * call to have already synthesized a `turn/end interrupted` closer (DSH core
+ * only writes that closer when something loads/prepares the specific
+ * session — a genuinely fresh crash's raw log has no closer at all, only an
+ * open turn). Safe to call ONLY right after a fresh `dsh web` boot, when
+ * `dsh web` is the sole live process for these sessions — an open turn found
+ * at that moment cannot belong to a still-running generation anywhere else.
+ * Callers MUST additionally skip any id that is live in their own current
+ * process (e.g. `ctx.sessions.get(id)`) before treating a match as crashed.
+ */
+export declare function findDanglingOpenTurns(dshHome?: string, opts?: FindInterruptedOpts): Promise<ResumeResult>;
+export declare function parseDuration(s: string): number | undefined;

package/lib/resume.js

@@ -1,11 +1,49 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
-export async function findInterrupted(dshHome) {
+/**
+ * Read the last ~100 lines of one session's raw log, applying the mtime
+ * pre-filter before any (potentially expensive) zstd decompression: a
+ * session log's mtime only advances when something is appended to it, so a
+ * file older than `sinceMs` cannot contain anything within the window.
+ * Shared by every raw-log scan below so the pre-filter (Critical: this
+ * scan previously blocked the host event loop ~5.5s across 412 sessions on
+ * a real machine before this filter existed) can't be accidentally
+ * bypassed by a future scan variant.
+ * @returns `undefined` when the session has no log file, or is filtered
+ *   out by `sinceMs` — callers must treat that the same as "nothing found".
+ */
+async function readSessionTailLines(zstdPath, jsonlPath, sinceMs) {
+    if (sinceMs !== undefined) {
+        try {
+            const statPath = fs.existsSync(zstdPath) ? zstdPath : (fs.existsSync(jsonlPath) ? jsonlPath : undefined);
+            if (statPath) {
+                const mtimeMs = fs.statSync(statPath).mtimeMs;
+                if (mtimeMs < sinceMs)
+                    return undefined;
+            }
+        }
+        catch { }
+    }
+    if (fs.existsSync(zstdPath)) {
+        const { execSync } = await import('node:child_process');
+        const out = execSync(`zstd -d -c ${JSON.stringify(zstdPath)} 2>/dev/null | tail -100`, { encoding: 'utf-8' });
+        return out.split('\n').filter(Boolean);
+    }
+    if (fs.existsSync(jsonlPath)) {
+        const content = fs.readFileSync(jsonlPath, 'utf-8');
+        return content.trim().split('\n').slice(-100);
+    }
+    return undefined;
+}
+export async function findInterrupted(dshHome, opts) {
     const home = dshHome ?? path.join(os.homedir(), '.dsh');
     const sessionsRoot = path.join(home, 'sessions');
     let scanned = 0;
     const interrupted = [];
+    const now = Date.now();
+    const withinMs = opts?.withinMs;
+    const sinceMs = opts?.sinceMs ?? (withinMs !== undefined ? now - withinMs : undefined);
     try {
         const groups = fs.readdirSync(sessionsRoot, { withFileTypes: true });
         for (const g of groups) {
@@ -20,17 +58,34 @@ export async function findInterrupted(dshHome) {
                 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' });
+                    const lines = await readSessionTailLines(zstdPath, jsonlPath, sinceMs);
+                    if (lines === undefined)
+                        continue;
+                    let found = false;
+                    let foundTime;
+                    for (let i = lines.length - 1; i >= 0; i--) {
+                        const line = lines[i];
+                        try {
+                            const obj = JSON.parse(line);
+                            foundTime = typeof obj.time === 'number' ? obj.time : undefined;
+                            if (obj.type === 'turn/end' && obj.data?.reason?.kind === 'interrupted') {
+                                found = true;
+                                break;
+                            }
+                        }
+                        catch { }
                     }
-                    else if (fs.existsSync(jsonlPath)) {
-                        content = fs.readFileSync(jsonlPath, 'utf-8').slice(-5000);
+                    if (!found)
+                        continue;
+                    if (sinceMs !== undefined && foundTime !== undefined) {
+                        if (foundTime < sinceMs)
+                            continue; // too old
                     }
-                    if (content.toLowerCase().includes('interrupted')) {
-                        interrupted.push(`${g.name}/${s.name}`);
+                    else if (sinceMs !== undefined && foundTime === undefined) {
+                        // no timestamp, skip when filtering by time
+                        continue;
                     }
+                    interrupted.push(`${g.name}/${s.name}`);
                 }
                 catch { }
             }
@@ -39,3 +94,120 @@ export async function findInterrupted(dshHome) {
     catch { }
     return { scanned, interrupted };
 }
+/**
+ * Read the entire log for a recent session (mtime within window) to find an
+ * open turn that may be far from the tail. Used only by
+ * {@link findDanglingOpenTurns}, which must see the last `turn/start`
+ * even when the file is 1906 lines and the open turn is at line 2 (subagent
+ * `b6487e33` had its only `turn/start` at seq 6, missed by `tail -100`).
+ * The mtime pre-filter ensures this full decompression runs only for
+ * recent sessions (within 5m, typically 1-2 files), not for all 425.
+ */
+async function readSessionAllLines(zstdPath, jsonlPath, sinceMs) {
+    if (sinceMs !== undefined) {
+        try {
+            const statPath = fs.existsSync(zstdPath) ? zstdPath : (fs.existsSync(jsonlPath) ? jsonlPath : undefined);
+            if (statPath) {
+                const mtimeMs = fs.statSync(statPath).mtimeMs;
+                if (mtimeMs < sinceMs)
+                    return undefined;
+            }
+        }
+        catch { }
+    }
+    if (fs.existsSync(zstdPath)) {
+        const { execSync } = await import('node:child_process');
+        const out = execSync(`zstd -d -c ${JSON.stringify(zstdPath)} 2>/dev/null`, { encoding: 'utf-8' });
+        return out.split('\n').filter(Boolean);
+    }
+    if (fs.existsSync(jsonlPath)) {
+        const content = fs.readFileSync(jsonlPath, 'utf-8');
+        return content.trim().split('\n').filter(Boolean);
+    }
+    return undefined;
+}
+/**
+ * Detect sessions whose raw log ends with a `turn/start` that has no
+ * matching `turn/end` anywhere later in the scanned log — a dangling open
+ * turn. Unlike {@link findInterrupted}, this needs no prior `persistence.load()`
+ * call to have already synthesized a `turn/end interrupted` closer (DSH core
+ * only writes that closer when something loads/prepares the specific
+ * session — a genuinely fresh crash's raw log has no closer at all, only an
+ * open turn). Safe to call ONLY right after a fresh `dsh web` boot, when
+ * `dsh web` is the sole live process for these sessions — an open turn found
+ * at that moment cannot belong to a still-running generation anywhere else.
+ * Callers MUST additionally skip any id that is live in their own current
+ * process (e.g. `ctx.sessions.get(id)`) before treating a match as crashed.
+ */
+export async function findDanglingOpenTurns(dshHome, opts) {
+    const home = dshHome ?? path.join(os.homedir(), '.dsh');
+    const sessionsRoot = path.join(home, 'sessions');
+    let scanned = 0;
+    const interrupted = [];
+    const now = Date.now();
+    const withinMs = opts?.withinMs;
+    const sinceMs = opts?.sinceMs ?? (withinMs !== undefined ? now - withinMs : undefined);
+    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 {
+                    const lines = await readSessionAllLines(zstdPath, jsonlPath, sinceMs);
+                    if (lines === undefined)
+                        continue;
+                    let openTurn;
+                    let openTurnTime;
+                    for (const line of lines) {
+                        try {
+                            const obj = JSON.parse(line);
+                            if (obj.type === 'turn/start' && typeof obj.data?.turn === 'number') {
+                                openTurn = obj.data.turn;
+                                openTurnTime = typeof obj.time === 'number' ? obj.time : undefined;
+                            }
+                            else if (obj.type === 'turn/end' && obj.data?.turn === openTurn) {
+                                openTurn = undefined;
+                                openTurnTime = undefined;
+                            }
+                        }
+                        catch { }
+                    }
+                    if (openTurn === undefined)
+                        continue;
+                    if (sinceMs !== undefined) {
+                        if (openTurnTime === undefined || openTurnTime < sinceMs)
+                            continue;
+                    }
+                    interrupted.push(`${g.name}/${s.name}`);
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+    return { scanned, interrupted };
+}
+export function parseDuration(s) {
+    if (!s)
+        return undefined;
+    const m = s.trim().match(/^(\d+)(s|m|h)?$/);
+    if (!m)
+        return undefined;
+    const n = parseInt(m[1], 10);
+    const unit = m[2] ?? 's';
+    if (unit === 's')
+        return n * 1000;
+    if (unit === 'm')
+        return n * 60 * 1000;
+    if (unit === 'h')
+        return n * 60 * 60 * 1000;
+    return undefined;
+}

package/lib/snapshot.d.ts

@@ -10,6 +10,9 @@ export declare function writeLKG(dshHome: string, lkgRoot: string): Promise<{
     ts: string;
     manifest: Manifest;
 }>;
+export declare function pruneByAge(root: string, maxAgeMs: number): Promise<void>;
+export declare function pruneBySize(root: string, maxBytes: number): Promise<void>;
+export declare function isDuplicateLKG(dshHome: string, lkgRoot: string): Promise<boolean>;
 export declare function verifyLKG(lkgPath: string): Promise<boolean>;
 export declare function rotateLKG(lkgRoot: string, keep?: number): Promise<void>;
 export declare function writeFailed(dshHome: string, failedRoot: string): Promise<{