@oyasmi/pipiclaw 0.5.9 → 0.6.1

package/dist/runtime/dingtalk.js

@@ -78,6 +78,7 @@ export class DingTalkBot {
         this.isReconnecting = false;
         this.isStopped = false;
         this.reconnectAttempts = 0;
+        this.hasReportedReady = false;
         // Deduplication cache (Set for O(1) lookup, order array for FIFO eviction)
         this.processedIds = new Set();
         this.processedIdsOrder = [];
@@ -180,8 +181,10 @@ export class DingTalkBot {
         this.client.registerCallbackListener(TOPIC_ROBOT, (msg) => {
             return this.handleRawMessage(msg);
         });
-        log.logConnected();
-        await this.doReconnect(true); // Initial connection
+        const connected = await this.doReconnect(true); // Initial connection
+        if (!connected) {
+            log.logWarning("DingTalk: initial stream connection not ready yet; retrying in background");
+        }
     }
     handleRawMessage(msg) {
         // 1. Immediate ACK
@@ -213,16 +216,17 @@ export class DingTalkBot {
     }
     async doReconnect(immediate = false) {
         if (this.isReconnecting || this.isStopped || !this.client)
-            return;
+            return false;
         this.isReconnecting = true;
         let connectionFailed = false;
+        let connected = false;
         if (!immediate && this.reconnectAttempts > 0) {
             const delay = Math.min(1000 * 2 ** this.reconnectAttempts + Math.random() * 1000, 30000);
             log.logInfo(`DingTalk: waiting ${Math.round(delay / 1000)}s before reconnecting...`);
             await this.waitForDelay(delay);
             if (this.isStopped || !this.client) {
                 this.isReconnecting = false;
-                return;
+                return false;
             }
         }
         try {
@@ -234,6 +238,11 @@ export class DingTalkBot {
             this.lastSocketAvailableTime = Date.now();
             this.reconnectAttempts = 0; // Success, reset backoff
             log.logInfo("DingTalk: connected to stream.");
+            if (!this.hasReportedReady) {
+                log.logConnected();
+                this.hasReportedReady = true;
+            }
+            connected = true;
             // Setup keep alive
             this.clearKeepAliveTimer();
             this.keepAliveTimer = this.setTrackedInterval(() => {
@@ -291,6 +300,7 @@ export class DingTalkBot {
         if (connectionFailed && !this.isStopped) {
             this.scheduleReconnect(0, false);
         }
+        return connected;
     }
     async stop() {
         log.logInfo("DingTalk: stopping bot");
@@ -352,48 +362,80 @@ export class DingTalkBot {
         await this.createCard(channelId);
     }
     /**
-     * Stream content to the active AI Card for a channel.
+     * Replace the active card content with a full snapshot.
      */
-    async streamToCard(channelId, content, finalize = false) {
+    async replaceCard(channelId, content, finalize = false, failed = false) {
         let card = this.activeCards.get(channelId);
-        if ((!card || card.finished) && !finalize && this.config.cardTemplateId && content.trim()) {
+        if ((!card || card.finished) && this.config.cardTemplateId && (content.trim() || !finalize || failed)) {
             await this.ensureCard(channelId);
             card = this.activeCards.get(channelId);
         }
         if (!card || card.finished) {
-            if (finalize) {
+            if (finalize && content.trim()) {
                 return this.sendPlain(channelId, content);
             }
             return false;
         }
-        const streamed = await this.streamCard(card, content, finalize);
-        if (!streamed) {
+        const streamed = await this.streamCard(card, content, {
+            append: false,
+            finalize,
+            failed,
+        });
+        if (!streamed || finalize || failed) {
             this.activeCards.delete(channelId);
         }
         return streamed;
     }
     /**
-     * Finalize the active card for a channel without falling back to a plain message.
-     * Returns true if a card was finalized, false if no active card existed.
+     * Append a delta to the active card transcript.
      */
-    async finalizeExistingCard(channelId, content) {
+    async appendToCard(channelId, content, finalize = false, failed = false) {
+        if (!content && !finalize && !failed) {
+            return true;
+        }
         let card = this.activeCards.get(channelId);
-        if ((!card || card.finished) && this.config.cardTemplateId && content.trim()) {
+        if ((!card || card.finished) && !finalize && !failed && this.config.cardTemplateId && content.trim()) {
             await this.ensureCard(channelId);
             card = this.activeCards.get(channelId);
         }
         if (!card || card.finished) {
+            if (finalize && content.trim()) {
+                return this.sendPlain(channelId, content);
+            }
             return false;
         }
-        const finalized = await this.streamCard(card, content, true);
-        this.activeCards.delete(channelId);
-        return finalized;
+        const streamed = await this.streamCard(card, content, {
+            append: true,
+            finalize,
+            failed,
+        });
+        if (!streamed || finalize || failed) {
+            this.activeCards.delete(channelId);
+        }
+        return streamed;
+    }
+    /**
+     * Stream content to the active AI Card for a channel using full replacement semantics.
+     */
+    async streamToCard(channelId, content, finalize = false) {
+        return this.replaceCard(channelId, content, finalize, false);
+    }
+    /**
+     * Finalize the active card for a channel without falling back to a plain message.
+     * Returns true if a card was finalized, false if no active card existed.
+     */
+    async finalizeExistingCard(channelId, content) {
+        const finalized = await this.replaceCard(channelId, content, true, false);
+        if (!finalized) {
+            return false;
+        }
+        return true;
     }
     /**
      * Finalize and remove the active card for a channel.
      */
     async finalizeCard(channelId, content) {
-        const finalized = await this.finalizeExistingCard(channelId, content);
+        const finalized = await this.replaceCard(channelId, content, true, false);
         if (!finalized) {
             return this.sendPlain(channelId, content);
         }
@@ -519,7 +561,7 @@ export class DingTalkBot {
         this.activeCards.set(channelId, card);
         return card;
     }
-    async streamCard(card, content, finalize = false) {
+    async streamCard(card, content, options) {
         // Refresh token if needed
         const ageSecs = Date.now() / 1000 - card.createdAt;
         if (ageSecs > TOKEN_REFRESH_SECS) {
@@ -533,9 +575,12 @@ export class DingTalkBot {
             guid: `${Date.now()}_${Math.random().toString(36).substring(2, 8)}`,
             key: card.templateKey,
             content,
-            isFull: true,
-            isFinalize: finalize,
-            isError: false,
+            append: options.append,
+            finished: options.finalize,
+            failed: options.failed,
+            isFull: !options.append,
+            isFinalize: options.finalize,
+            isError: options.failed,
         };
         const start = Date.now();
         try {
@@ -550,8 +595,8 @@ export class DingTalkBot {
                 log.logWarning(`DingTalk Card: streaming request took ${duration}ms (slow)`);
             }
             card.lastUpdated = Date.now() / 1000;
-            card.content = content;
-            if (finalize) {
+            card.content = options.append ? `${card.content}${content}` : content;
+            if (options.finalize || options.failed) {
                 card.finished = true;
             }
             return true;

package/dist/runtime/events.d.ts

@@ -1,14 +1,22 @@
+import type { SecurityConfig } from "../security/types.js";
 import type { DingTalkBot } from "./dingtalk.js";
+export interface EventAction {
+    type: "bash";
+    command: string;
+    timeout?: number;
+}
 export interface ImmediateEvent {
     type: "immediate";
     channelId: string;
     text: string;
+    preAction?: EventAction;
 }
 export interface OneShotEvent {
     type: "one-shot";
     channelId: string;
     text: string;
     at: string;
+    preAction?: EventAction;
 }
 export interface PeriodicEvent {
     type: "periodic";
@@ -16,18 +24,20 @@ export interface PeriodicEvent {
     text: string;
     schedule: string;
     timezone: string;
+    preAction?: EventAction;
 }
 export type ScheduledEvent = ImmediateEvent | OneShotEvent | PeriodicEvent;
 export declare class EventsWatcher {
     private eventsDir;
     private bot;
+    private commandGuardConfig?;
     private timers;
     private crons;
     private debounceTimers;
     private startTime;
     private watcher;
     private knownFiles;
-    constructor(eventsDir: string, bot: DingTalkBot);
+    constructor(eventsDir: string, bot: DingTalkBot, commandGuardConfig?: SecurityConfig["commandGuard"] | undefined);
     start(): void;
     stop(): void;
     private debounce;
@@ -36,15 +46,20 @@ export declare class EventsWatcher {
     private handleDelete;
     private cancelScheduled;
     private handleFile;
+    private parsePreAction;
     private parseEvent;
     private handleImmediate;
     private handleOneShot;
     private handlePeriodic;
     private execute;
+    private runPreAction;
     private deleteFile;
+    private getInvalidMarkerPath;
+    private markInvalid;
+    private clearInvalidMarker;
     private sleep;
 }
 /**
  * Create and start an events watcher.
  */
-export declare function createEventsWatcher(workspaceDir: string, bot: DingTalkBot): EventsWatcher;
+export declare function createEventsWatcher(workspaceDir: string, bot: DingTalkBot, commandGuardConfig?: SecurityConfig["commandGuard"]): EventsWatcher;

package/dist/runtime/events.js

@@ -1,8 +1,10 @@
+import { exec } from "child_process";
 import { Cron } from "croner";
-import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, watch } from "fs";
+import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, watch, writeFileSync } from "fs";
 import { readFile } from "fs/promises";
 import { join } from "path";
 import * as log from "../log.js";
+import { guardCommand } from "../security/command-guard.js";
 // ============================================================================
 // EventsWatcher
 // ============================================================================
@@ -11,9 +13,10 @@ const MAX_RETRIES = 3;
 const RETRY_BASE_MS = 100;
 const MAX_TIMEOUT_MS = 2_147_483_647;
 export class EventsWatcher {
-    constructor(eventsDir, bot) {
+    constructor(eventsDir, bot, commandGuardConfig) {
         this.eventsDir = eventsDir;
         this.bot = bot;
+        this.commandGuardConfig = commandGuardConfig;
         this.timers = new Map();
         this.crons = new Map();
         this.debounceTimers = new Map();
@@ -128,10 +131,11 @@ export class EventsWatcher {
         }
         if (!event) {
             log.logWarning(`Failed to parse event file after ${MAX_RETRIES} retries: ${filename}`, lastError?.message);
-            this.deleteFile(filename);
+            this.markInvalid(filename, lastError?.message ?? "Unknown event parse error");
             return;
         }
         this.knownFiles.add(filename);
+        this.clearInvalidMarker(filename);
         switch (event.type) {
             case "immediate":
                 this.handleImmediate(filename, event);
@@ -144,19 +148,39 @@ export class EventsWatcher {
                 break;
         }
     }
+    parsePreAction(data, filename) {
+        if (!data.preAction)
+            return undefined;
+        if (typeof data.preAction !== "object" || data.preAction === null) {
+            throw new Error(`Invalid 'preAction' field in ${filename}, expected an object`);
+        }
+        const action = data.preAction;
+        if (action.type !== "bash") {
+            throw new Error(`Unsupported preAction type '${String(action.type)}' in ${filename}, only 'bash' is supported`);
+        }
+        if (typeof action.command !== "string" || action.command.trim().length === 0) {
+            throw new Error(`Missing or empty 'preAction.command' in ${filename}`);
+        }
+        return {
+            type: "bash",
+            command: action.command,
+            ...(typeof action.timeout === "number" ? { timeout: action.timeout } : {}),
+        };
+    }
     parseEvent(content, filename) {
         const data = JSON.parse(content);
         if (!data.type || !data.channelId || !data.text) {
             throw new Error(`Missing required fields (type, channelId, text) in ${filename}`);
         }
+        const preAction = this.parsePreAction(data, filename);
         switch (data.type) {
             case "immediate":
-                return { type: "immediate", channelId: data.channelId, text: data.text };
+                return { type: "immediate", channelId: data.channelId, text: data.text, preAction };
             case "one-shot":
                 if (!data.at) {
                     throw new Error(`Missing 'at' field for one-shot event in ${filename}`);
                 }
-                return { type: "one-shot", channelId: data.channelId, text: data.text, at: data.at };
+                return { type: "one-shot", channelId: data.channelId, text: data.text, at: data.at, preAction };
             case "periodic":
                 if (!data.schedule) {
                     throw new Error(`Missing 'schedule' field for periodic event in ${filename}`);
@@ -170,12 +194,13 @@ export class EventsWatcher {
                     text: data.text,
                     schedule: data.schedule,
                     timezone: data.timezone,
+                    preAction,
                 };
             default:
                 throw new Error(`Unknown event type '${data.type}' in ${filename}`);
         }
     }
-    handleImmediate(filename, event) {
+    async handleImmediate(filename, event) {
         const filePath = join(this.eventsDir, filename);
         try {
             const stat = statSync(filePath);
@@ -189,14 +214,14 @@ export class EventsWatcher {
             return;
         }
         log.logInfo(`Executing immediate event: ${filename}`);
-        this.execute(filename, event);
+        await this.execute(filename, event);
     }
     handleOneShot(filename, event) {
         const atTime = new Date(event.at).getTime();
         const now = Date.now();
         if (!Number.isFinite(atTime)) {
             log.logWarning(`Invalid one-shot time for ${filename}: ${event.at}`);
-            this.deleteFile(filename);
+            this.markInvalid(filename, `Invalid one-shot time: ${event.at}`);
             return;
         }
         if (atTime <= now) {
@@ -207,22 +232,32 @@ export class EventsWatcher {
         const delay = atTime - now;
         if (delay > MAX_TIMEOUT_MS) {
             log.logWarning(`One-shot event exceeds maximum supported delay for ${filename}: ${event.at}. Use a periodic cron event instead.`);
-            this.deleteFile(filename);
+            this.markInvalid(filename, `One-shot event exceeds maximum supported delay: ${event.at}`);
             return;
         }
         log.logInfo(`Scheduling one-shot event: ${filename} in ${Math.round(delay / 1000)}s`);
-        const timer = setTimeout(() => {
+        const timer = setTimeout(async () => {
             this.timers.delete(filename);
-            log.logInfo(`Executing one-shot event: ${filename}`);
-            this.execute(filename, event);
+            try {
+                log.logInfo(`Executing one-shot event: ${filename}`);
+                await this.execute(filename, event);
+            }
+            catch (err) {
+                log.logWarning(`One-shot event execution failed: ${filename}`, String(err));
+            }
         }, delay);
         this.timers.set(filename, timer);
     }
     handlePeriodic(filename, event) {
         try {
-            const cron = new Cron(event.schedule, { timezone: event.timezone }, () => {
-                log.logInfo(`Executing periodic event: ${filename}`);
-                this.execute(filename, event, false);
+            const cron = new Cron(event.schedule, { timezone: event.timezone }, async () => {
+                try {
+                    log.logInfo(`Executing periodic event: ${filename}`);
+                    await this.execute(filename, event, false);
+                }
+                catch (err) {
+                    log.logWarning(`Periodic event execution failed: ${filename}`, String(err));
+                }
             });
             this.crons.set(filename, cron);
             const next = cron.nextRun();
@@ -230,10 +265,20 @@ export class EventsWatcher {
         }
         catch (err) {
             log.logWarning(`Invalid cron schedule for ${filename}: ${event.schedule}`, String(err));
-            this.deleteFile(filename);
+            this.markInvalid(filename, `Invalid cron schedule: ${event.schedule}\n${String(err)}`);
         }
     }
-    execute(filename, event, deleteAfter = true) {
+    async execute(filename, event, deleteAfter = true) {
+        if (event.preAction) {
+            try {
+                await this.runPreAction(event.preAction, filename);
+            }
+            catch (err) {
+                const reason = err instanceof Error ? err.message : String(err);
+                log.logInfo(`Pre-action gate blocked event: ${filename} (${reason})`);
+                return;
+            }
+        }
         let scheduleInfo;
         switch (event.type) {
             case "immediate":
@@ -269,6 +314,25 @@ export class EventsWatcher {
             }
         }
     }
+    runPreAction(action, filename) {
+        if (this.commandGuardConfig?.enabled) {
+            const guardResult = guardCommand(action.command, this.commandGuardConfig);
+            if (!guardResult.allowed) {
+                log.logWarning(`Pre-action command blocked by guard for ${filename}: ${guardResult.reason}`);
+                return Promise.reject(new Error(`guard: ${guardResult.reason}`));
+            }
+        }
+        return new Promise((resolve, reject) => {
+            const child = exec(action.command, { timeout: action.timeout ?? 10_000 });
+            child.on("close", (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`exit ${code}`));
+            });
+            child.on("error", reject);
+        });
+    }
     deleteFile(filename) {
         const filePath = join(this.eventsDir, filename);
         try {
@@ -279,8 +343,32 @@ export class EventsWatcher {
                 log.logWarning(`Failed to delete event file: ${filename}`, String(err));
             }
         }
+        this.clearInvalidMarker(filename);
         this.knownFiles.delete(filename);
     }
+    getInvalidMarkerPath(filename) {
+        return join(this.eventsDir, `${filename}.error.txt`);
+    }
+    markInvalid(filename, message) {
+        try {
+            writeFileSync(this.getInvalidMarkerPath(filename), [`timestamp: ${new Date().toISOString()}`, `file: ${filename}`, "", message.trim()].join("\n"), "utf-8");
+        }
+        catch (err) {
+            log.logWarning(`Failed to write event error marker: ${filename}`, String(err));
+        }
+        this.knownFiles.add(filename);
+    }
+    clearInvalidMarker(filename) {
+        const markerPath = this.getInvalidMarkerPath(filename);
+        try {
+            unlinkSync(markerPath);
+        }
+        catch (err) {
+            if (err instanceof Error && "code" in err && err.code !== "ENOENT") {
+                log.logWarning(`Failed to delete event error marker: ${filename}`, String(err));
+            }
+        }
+    }
     sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
@@ -288,7 +376,7 @@ export class EventsWatcher {
 /**
  * Create and start an events watcher.
  */
-export function createEventsWatcher(workspaceDir, bot) {
+export function createEventsWatcher(workspaceDir, bot, commandGuardConfig) {
     const eventsDir = join(workspaceDir, "events");
-    return new EventsWatcher(eventsDir, bot);
+    return new EventsWatcher(eventsDir, bot, commandGuardConfig);
 }

package/dist/security/command-guard.js

@@ -1,4 +1,5 @@
 import { basename } from "node:path";
+import { isWindowsPlatform } from "./platform.js";
 const WHITESPACE = /\s+/;
 function stripNullAndNormalize(text) {
     return text.replace(/\0/g, "").normalize("NFKC");
@@ -402,6 +403,9 @@ export function guardCommand(command, config) {
     if (!config.enabled) {
         return { allowed: true };
     }
+    if (isWindowsPlatform()) {
+        return { allowed: true };
+    }
     const atoms = splitCommandChain(command);
     const normalizedWhole = stripNullAndNormalize(command);
     for (const allowPattern of config.allowPatterns) {

package/dist/security/config.d.ts

@@ -1,4 +1,10 @@
+import type { ConfigDiagnostic } from "../shared/config-diagnostics.js";
 import type { SecurityConfig } from "./types.js";
+export interface LoadedSecurityConfig {
+    config: SecurityConfig;
+    diagnostics: ConfigDiagnostic[];
+}
 export declare const DEFAULT_SECURITY_CONFIG: SecurityConfig;
 export declare function getSecurityConfigPath(appHomeDir?: string): string;
+export declare function loadSecurityConfigWithDiagnostics(appHomeDir?: string): LoadedSecurityConfig;
 export declare function loadSecurityConfig(appHomeDir?: string): SecurityConfig;

package/dist/security/config.js

@@ -34,14 +34,30 @@ function asStringArray(value) {
 function asOptionalString(value) {
     return typeof value === "string" && value.trim() ? value : undefined;
 }
-function mergeSecurityConfig(source) {
+function pushInvalidSecurityDiagnostic(diagnostics, configPath, field, message) {
+    diagnostics.push({
+        source: "security",
+        path: configPath,
+        severity: "warning",
+        message: `${field}: ${message}`,
+    });
+}
+function mergeSecurityConfig(source, configPath, diagnostics) {
     if (!isRecord(source)) {
+        pushInvalidSecurityDiagnostic(diagnostics, configPath, "root", "expected a JSON object; using defaults");
         return DEFAULT_SECURITY_CONFIG;
     }
     const commandGuard = isRecord(source.commandGuard) ? source.commandGuard : {};
     const pathGuard = isRecord(source.pathGuard) ? source.pathGuard : {};
     const networkGuard = isRecord(source.networkGuard) ? source.networkGuard : {};
     const audit = isRecord(source.audit) ? source.audit : {};
+    if (networkGuard.maxRedirects !== undefined) {
+        const maxRedirects = networkGuard.maxRedirects;
+        const isValidMaxRedirects = typeof maxRedirects === "number" && Number.isFinite(maxRedirects) && maxRedirects > 0;
+        if (!isValidMaxRedirects) {
+            pushInvalidSecurityDiagnostic(diagnostics, configPath, "networkGuard.maxRedirects", "expected a positive integer; using default");
+        }
+    }
     return {
         enabled: typeof source.enabled === "boolean" ? source.enabled : DEFAULT_SECURITY_CONFIG.enabled,
         commandGuard: {
@@ -85,17 +101,33 @@ function mergeSecurityConfig(source) {
 export function getSecurityConfigPath(appHomeDir = APP_HOME_DIR) {
     return join(appHomeDir, "security.json");
 }
-export function loadSecurityConfig(appHomeDir = APP_HOME_DIR) {
+export function loadSecurityConfigWithDiagnostics(appHomeDir = APP_HOME_DIR) {
     const configPath = getSecurityConfigPath(appHomeDir);
     if (!existsSync(configPath)) {
-        return DEFAULT_SECURITY_CONFIG;
+        return { config: DEFAULT_SECURITY_CONFIG, diagnostics: [] };
     }
     try {
         const raw = JSON.parse(readFileSync(configPath, "utf-8"));
-        return mergeSecurityConfig(raw);
+        const diagnostics = [];
+        return {
+            config: mergeSecurityConfig(raw, configPath, diagnostics),
+            diagnostics,
+        };
     }
     catch (error) {
-        console.warn(`Failed to load security config from ${configPath}: ${error}`);
-        return DEFAULT_SECURITY_CONFIG;
+        return {
+            config: DEFAULT_SECURITY_CONFIG,
+            diagnostics: [
+                {
+                    source: "security",
+                    path: configPath,
+                    severity: "error",
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            ],
+        };
     }
 }
+export function loadSecurityConfig(appHomeDir = APP_HOME_DIR) {
+    return loadSecurityConfigWithDiagnostics(appHomeDir).config;
+}

package/dist/security/path-guard.js

@@ -1,6 +1,7 @@
 import { existsSync, lstatSync, realpathSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, normalize, resolve } from "node:path";
+import { isWindowsPlatform } from "./platform.js";
 const PRIVATE_KEY_EXTENSIONS = new Set([".pem", ".key", ".p12", ".pfx"]);
 const PRIVATE_KEY_NAME_HINTS = /(id_rsa|id_ed25519|private|secret|credentials)/i;
 const PROC_MEM_PATH = /^\/proc\/\d+\/mem(?:\/|$)/;
@@ -197,6 +198,9 @@ export function guardPath(rawPath, operation, ctx) {
     if (!ctx.config.enabled) {
         return { allowed: true, operation, rawPath };
     }
+    if (isWindowsPlatform()) {
+        return { allowed: true, operation, rawPath };
+    }
     const homeDir = ctx.homeDir ?? homedir();
     const effectiveCtx = {
         ...ctx,

package/dist/security/platform.d.ts

@@ -0,0 +1 @@
+export declare function isWindowsPlatform(): boolean;

package/dist/security/platform.js

@@ -0,0 +1,3 @@
+export function isWindowsPlatform() {
+    return process.platform === "win32";
+}

package/dist/settings.d.ts

@@ -7,6 +7,7 @@
  * This module currently provides only PipiclawSettingsManager.
  */
 import type { Transport } from "@mariozechner/pi-ai";
+import type { ConfigDiagnostic } from "./shared/config-diagnostics.js";
 type PackageSource = string | {
     source: string;
     extensions?: string[];
@@ -83,10 +84,13 @@ export interface PipiclawSettings {
 export declare class PipiclawSettingsManager {
     private settingsPath;
     private settings;
+    private loadErrors;
     constructor(baseDir: string);
     private load;
     private save;
     reload(): void;
+    drainErrors(): SettingsError[];
+    getDiagnostics(): ConfigDiagnostic[];
     getCompactionSettings(): PipiclawCompactionSettings;
     getCompactionEnabled(): boolean;
     setCompactionEnabled(enabled: boolean): void;
@@ -176,6 +180,5 @@ export declare class PipiclawSettingsManager {
     getProjectSettings(): Settings;
     applyOverrides(overrides: Partial<Settings>): void;
     flush(): Promise<void>;
-    drainErrors(): SettingsError[];
 }
 export {};