@bubblebrain-ai/bubble 0.0.10 → 0.0.12

package/dist/feishu/router/whitelist.js

@@ -0,0 +1,20 @@
+/**
+ * Three gates: scope (chat known?), user (in allowedUsers?), mention (group + requireMention?).
+ *
+ * Failed gates return reasons that the caller may log but should NOT reflect
+ * back to the user (silent drop) — surfacing the bot's existence is its own
+ * security exposure.
+ */
+export function checkWhitelist(input) {
+    if (!input.scope)
+        return { ok: false, reason: "scope_not_found" };
+    if (input.chatType === "topic")
+        return { ok: false, reason: "topic_chat_unsupported" };
+    if (!input.scope.allowedUsers.includes(input.userId)) {
+        return { ok: false, reason: "user_not_allowed" };
+    }
+    if (input.chatType === "group" && input.requireMentionInGroup && !input.mentionedBot) {
+        return { ok: false, reason: "no_mention_in_group" };
+    }
+    return { ok: true };
+}

package/dist/feishu/runtime/active-runs.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Per-scope active-run tracker with preemption.
+ *
+ * Same scopeKey can have at most one run. Starting a new one aborts the
+ * previous one's AbortController and waits (briefly) for it to settle
+ * before resolving startOrReplace().
+ */
+import type { ScopeKey } from "../types.js";
+export declare class ActiveRuns {
+    private readonly runs;
+    isActive(scopeKey: ScopeKey): boolean;
+    getSignal(scopeKey: ScopeKey): AbortSignal | undefined;
+    /**
+     * Register a new run for `scopeKey`. If one was already active, aborts it
+     * and awaits its settlement (capped at `waitMs`) before returning the new
+     * AbortSignal.
+     *
+     * Caller is responsible for calling `complete(scopeKey)` (or letting the
+     * donePromise resolve) when its work is done.
+     */
+    startOrReplace(scopeKey: ScopeKey, waitMs?: number): Promise<{
+        signal: AbortSignal;
+        complete: () => void;
+    }>;
+    /** Abort a single scope's run. Used by /stop and shutdown. */
+    abort(scopeKey: ScopeKey): boolean;
+    /** Abort all active runs. Returns the number aborted. */
+    abortAll(): number;
+    /** Wait for all current runs to settle, capped at `maxWaitMs`. */
+    waitAll(maxWaitMs?: number): Promise<void>;
+    size(): number;
+}

package/dist/feishu/runtime/active-runs.js

@@ -0,0 +1,84 @@
+/**
+ * Per-scope active-run tracker with preemption.
+ *
+ * Same scopeKey can have at most one run. Starting a new one aborts the
+ * previous one's AbortController and waits (briefly) for it to settle
+ * before resolving startOrReplace().
+ */
+export class ActiveRuns {
+    runs = new Map();
+    isActive(scopeKey) {
+        return this.runs.has(scopeKey);
+    }
+    getSignal(scopeKey) {
+        return this.runs.get(scopeKey)?.abortController.signal;
+    }
+    /**
+     * Register a new run for `scopeKey`. If one was already active, aborts it
+     * and awaits its settlement (capped at `waitMs`) before returning the new
+     * AbortSignal.
+     *
+     * Caller is responsible for calling `complete(scopeKey)` (or letting the
+     * donePromise resolve) when its work is done.
+     */
+    async startOrReplace(scopeKey, waitMs = 10_000) {
+        const existing = this.runs.get(scopeKey);
+        if (existing) {
+            existing.abortController.abort();
+            // Wait for prior run to finish so we don't double-spend the pool slot.
+            await Promise.race([
+                existing.donePromise,
+                new Promise((resolve) => setTimeout(resolve, waitMs)),
+            ]);
+        }
+        const abortController = new AbortController();
+        let resolveDone;
+        const donePromise = new Promise((res) => {
+            resolveDone = res;
+        });
+        const handle = {
+            abortController,
+            donePromise,
+            startedAt: Date.now(),
+        };
+        this.runs.set(scopeKey, handle);
+        const complete = () => {
+            const current = this.runs.get(scopeKey);
+            if (current === handle) {
+                this.runs.delete(scopeKey);
+            }
+            resolveDone();
+        };
+        return { signal: abortController.signal, complete };
+    }
+    /** Abort a single scope's run. Used by /stop and shutdown. */
+    abort(scopeKey) {
+        const handle = this.runs.get(scopeKey);
+        if (!handle)
+            return false;
+        handle.abortController.abort();
+        return true;
+    }
+    /** Abort all active runs. Returns the number aborted. */
+    abortAll() {
+        let count = 0;
+        for (const handle of this.runs.values()) {
+            handle.abortController.abort();
+            count++;
+        }
+        return count;
+    }
+    /** Wait for all current runs to settle, capped at `maxWaitMs`. */
+    async waitAll(maxWaitMs = 10_000) {
+        const promises = Array.from(this.runs.values()).map((h) => h.donePromise);
+        if (promises.length === 0)
+            return;
+        await Promise.race([
+            Promise.all(promises),
+            new Promise((resolve) => setTimeout(resolve, maxWaitMs)),
+        ]);
+    }
+    size() {
+        return this.runs.size;
+    }
+}

package/dist/feishu/runtime/pending-queue.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Per-scope inbound message debounce. Coalesces messages arriving within
+ * `debounceMs` of each other into a single prompt, so a user typing
+ * fragments doesn't kick off N parallel runs.
+ *
+ * Lifecycle per scopeKey:
+ *   push(scopeKey, msg) → start/reset timer
+ *   timer fires → flush queued messages as combined prompt, call onFlush()
+ *   block(scopeKey) → suppress flushes until unblock() (used while a run is in flight)
+ *   unblock(scopeKey) → resume; if queue non-empty, flush immediately
+ */
+import type { ScopeKey } from "../types.js";
+export interface QueuedMessage {
+    text: string;
+    messageId: string;
+    receivedAt: number;
+}
+export interface PendingQueueOptions {
+    debounceMs: number;
+    onFlush: (scopeKey: ScopeKey, batch: QueuedMessage[]) => void | Promise<void>;
+}
+export declare class PendingQueue {
+    private readonly opts;
+    private readonly states;
+    constructor(opts: PendingQueueOptions);
+    push(scopeKey: ScopeKey, msg: QueuedMessage): void;
+    /** Suspend flushing for `scopeKey` while a run is in flight. */
+    block(scopeKey: ScopeKey): void;
+    unblock(scopeKey: ScopeKey): void;
+    /** Stop all timers (used at shutdown). Does not flush. */
+    shutdown(): void;
+    private resetTimer;
+    private flush;
+}
+/** Concatenate queued messages into a single user prompt. */
+export declare function combineQueuedMessages(batch: QueuedMessage[]): string;

package/dist/feishu/runtime/pending-queue.js

@@ -0,0 +1,98 @@
+/**
+ * Per-scope inbound message debounce. Coalesces messages arriving within
+ * `debounceMs` of each other into a single prompt, so a user typing
+ * fragments doesn't kick off N parallel runs.
+ *
+ * Lifecycle per scopeKey:
+ *   push(scopeKey, msg) → start/reset timer
+ *   timer fires → flush queued messages as combined prompt, call onFlush()
+ *   block(scopeKey) → suppress flushes until unblock() (used while a run is in flight)
+ *   unblock(scopeKey) → resume; if queue non-empty, flush immediately
+ */
+export class PendingQueue {
+    opts;
+    states = new Map();
+    constructor(opts) {
+        this.opts = opts;
+    }
+    push(scopeKey, msg) {
+        let state = this.states.get(scopeKey);
+        if (!state) {
+            state = { messages: [], blocked: false };
+            this.states.set(scopeKey, state);
+        }
+        state.messages.push(msg);
+        if (state.blocked)
+            return;
+        this.resetTimer(scopeKey);
+    }
+    /** Suspend flushing for `scopeKey` while a run is in flight. */
+    block(scopeKey) {
+        let state = this.states.get(scopeKey);
+        if (!state) {
+            state = { messages: [], blocked: true };
+            this.states.set(scopeKey, state);
+            return;
+        }
+        state.blocked = true;
+        if (state.timer) {
+            clearTimeout(state.timer);
+            state.timer = undefined;
+        }
+    }
+    unblock(scopeKey) {
+        const state = this.states.get(scopeKey);
+        if (!state)
+            return;
+        state.blocked = false;
+        if (state.messages.length > 0) {
+            // Flush immediately — debounce already elapsed conceptually while we
+            // were blocked.
+            void this.flush(scopeKey);
+        }
+    }
+    /** Stop all timers (used at shutdown). Does not flush. */
+    shutdown() {
+        for (const state of this.states.values()) {
+            if (state.timer) {
+                clearTimeout(state.timer);
+                state.timer = undefined;
+            }
+        }
+        this.states.clear();
+    }
+    resetTimer(scopeKey) {
+        const state = this.states.get(scopeKey);
+        if (!state)
+            return;
+        if (state.timer)
+            clearTimeout(state.timer);
+        state.timer = setTimeout(() => {
+            void this.flush(scopeKey);
+        }, this.opts.debounceMs);
+    }
+    async flush(scopeKey) {
+        const state = this.states.get(scopeKey);
+        if (!state)
+            return;
+        if (state.blocked)
+            return;
+        if (state.messages.length === 0)
+            return;
+        const batch = state.messages;
+        state.messages = [];
+        state.timer = undefined;
+        try {
+            await this.opts.onFlush(scopeKey, batch);
+        }
+        catch {
+            // Errors are caller's responsibility to surface; never crash the queue.
+        }
+    }
+}
+/** Concatenate queued messages into a single user prompt. */
+export function combineQueuedMessages(batch) {
+    if (batch.length === 1)
+        return batch[0].text;
+    return batch.map((m) => m.text).join("\n\n");
+}

package/dist/feishu/runtime/process-pool.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Global concurrency cap. FIFO queue of tasks; at most `concurrency` in
+ * flight at any time.
+ *
+ * Bubble agents are CPU-light but LLM-network-heavy. The cap exists to
+ * (a) cap egress bandwidth and (b) keep API rate-limit failures localized.
+ */
+export interface ProcessPoolOptions {
+    concurrency: number;
+}
+export declare class ProcessPool {
+    private readonly opts;
+    private active;
+    private readonly waiters;
+    constructor(opts: ProcessPoolOptions);
+    /**
+     * Acquire a slot. Caller must call `release()` exactly once when done
+     * (or use `run()` for the safer wrapped variant).
+     */
+    acquire(): Promise<void>;
+    release(): void;
+    /** Run `fn` with a pool slot held; releases on settle. */
+    run<T>(fn: () => Promise<T>): Promise<T>;
+    status(): {
+        active: number;
+        waiting: number;
+        cap: number;
+    };
+}

package/dist/feishu/runtime/process-pool.js

@@ -0,0 +1,49 @@
+/**
+ * Global concurrency cap. FIFO queue of tasks; at most `concurrency` in
+ * flight at any time.
+ *
+ * Bubble agents are CPU-light but LLM-network-heavy. The cap exists to
+ * (a) cap egress bandwidth and (b) keep API rate-limit failures localized.
+ */
+export class ProcessPool {
+    opts;
+    active = 0;
+    waiters = [];
+    constructor(opts) {
+        this.opts = opts;
+        if (opts.concurrency < 1) {
+            throw new Error(`ProcessPool concurrency must be >= 1, got ${opts.concurrency}`);
+        }
+    }
+    /**
+     * Acquire a slot. Caller must call `release()` exactly once when done
+     * (or use `run()` for the safer wrapped variant).
+     */
+    async acquire() {
+        if (this.active < this.opts.concurrency) {
+            this.active++;
+            return;
+        }
+        await new Promise((resolve) => this.waiters.push(resolve));
+        this.active++;
+    }
+    release() {
+        this.active = Math.max(0, this.active - 1);
+        const next = this.waiters.shift();
+        if (next)
+            next();
+    }
+    /** Run `fn` with a pool slot held; releases on settle. */
+    async run(fn) {
+        await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            this.release();
+        }
+    }
+    status() {
+        return { active: this.active, waiting: this.waiters.length, cap: this.opts.concurrency };
+    }
+}

package/dist/feishu/schema.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Hand-rolled schema validation for Feishu config / scopes / sessions JSON.
+ *
+ * We avoid zod to keep dependency footprint flat. Each validator returns
+ * an array of human-readable errors; empty array means valid.
+ */
+import type { FeishuConfig, ScopesFile, ScopeConfig, SessionsFile, SessionEntry } from "./types.js";
+export interface ValidationResult<T> {
+    ok: boolean;
+    value?: T;
+    errors: string[];
+}
+export declare function validateFeishuConfig(raw: unknown): ValidationResult<FeishuConfig>;
+export declare function validateScopesFile(raw: unknown): ValidationResult<ScopesFile>;
+export declare function validateScopeConfig(raw: unknown): ValidationResult<ScopeConfig>;
+export declare function validateSessionsFile(raw: unknown): ValidationResult<SessionsFile>;
+export declare function validateSessionEntry(raw: unknown): ValidationResult<SessionEntry>;

package/dist/feishu/schema.js

@@ -0,0 +1,252 @@
+/**
+ * Hand-rolled schema validation for Feishu config / scopes / sessions JSON.
+ *
+ * We avoid zod to keep dependency footprint flat. Each validator returns
+ * an array of human-readable errors; empty array means valid.
+ */
+import { DEFAULT_PREFERENCES, DEFAULT_GLOBAL_LIMITS } from "./types.js";
+const PERMISSION_MODES = ["default", "plan", "bypassPermissions"];
+const RENDER_MODES = ["card", "markdown", "text"];
+function isString(v) {
+    return typeof v === "string";
+}
+function isNumber(v) {
+    return typeof v === "number" && Number.isFinite(v);
+}
+function isBoolean(v) {
+    return typeof v === "boolean";
+}
+function isObject(v) {
+    return !!v && typeof v === "object" && !Array.isArray(v);
+}
+function isStringArray(v) {
+    return Array.isArray(v) && v.every(isString);
+}
+export function validateFeishuConfig(raw) {
+    const errors = [];
+    if (!isObject(raw)) {
+        return { ok: false, errors: ["config must be an object"] };
+    }
+    if (raw.version !== 1)
+        errors.push(`config.version must be 1 (got ${String(raw.version)})`);
+    const app = raw.app;
+    if (!isObject(app)) {
+        errors.push("config.app must be an object");
+        return { ok: false, errors };
+    }
+    if (!isString(app.appId) || !app.appId.trim())
+        errors.push("config.app.appId must be a non-empty string");
+    if (!isString(app.ownerOpenId) || !app.ownerOpenId.trim())
+        errors.push("config.app.ownerOpenId must be a non-empty string");
+    if (!isString(app.encryptCheck))
+        errors.push("config.app.encryptCheck must be a string");
+    const secretRef = app.secretRef;
+    if (!isObject(secretRef) || !isString(secretRef.source)) {
+        errors.push("config.app.secretRef must be { source: 'keystore'|'env', ... }");
+    }
+    else if (secretRef.source === "keystore") {
+        if (!isString(secretRef.name) || !secretRef.name) {
+            errors.push("config.app.secretRef.name required when source=keystore");
+        }
+    }
+    else if (secretRef.source === "env") {
+        if (!isString(secretRef.varName) || !secretRef.varName) {
+            errors.push("config.app.secretRef.varName required when source=env");
+        }
+    }
+    else {
+        errors.push(`config.app.secretRef.source must be 'keystore' or 'env'`);
+    }
+    // Preferences: fill defaults for missing fields, validate provided ones.
+    const prefsRaw = isObject(raw.preferences) ? raw.preferences : {};
+    const preferences = { ...DEFAULT_PREFERENCES };
+    if (prefsRaw.outputThrottleMs !== undefined) {
+        if (!isNumber(prefsRaw.outputThrottleMs) || prefsRaw.outputThrottleMs < 50) {
+            errors.push("preferences.outputThrottleMs must be a number >= 50");
+        }
+        else {
+            preferences.outputThrottleMs = prefsRaw.outputThrottleMs;
+        }
+    }
+    if (prefsRaw.idleTimeoutMinutes !== undefined) {
+        if (!isNumber(prefsRaw.idleTimeoutMinutes) || prefsRaw.idleTimeoutMinutes < 1) {
+            errors.push("preferences.idleTimeoutMinutes must be a number >= 1");
+        }
+        else {
+            preferences.idleTimeoutMinutes = prefsRaw.idleTimeoutMinutes;
+        }
+    }
+    if (prefsRaw.renderMode !== undefined) {
+        if (!isString(prefsRaw.renderMode) || !RENDER_MODES.includes(prefsRaw.renderMode)) {
+            errors.push(`preferences.renderMode must be one of ${RENDER_MODES.join("|")}`);
+        }
+        else {
+            preferences.renderMode = prefsRaw.renderMode;
+        }
+    }
+    if (prefsRaw.requireMentionInGroup !== undefined) {
+        if (!isBoolean(prefsRaw.requireMentionInGroup)) {
+            errors.push("preferences.requireMentionInGroup must be boolean");
+        }
+        else {
+            preferences.requireMentionInGroup = prefsRaw.requireMentionInGroup;
+        }
+    }
+    if (prefsRaw.maxBytesPerElement !== undefined) {
+        if (!isNumber(prefsRaw.maxBytesPerElement) || prefsRaw.maxBytesPerElement < 1000) {
+            errors.push("preferences.maxBytesPerElement must be a number >= 1000");
+        }
+        else {
+            preferences.maxBytesPerElement = prefsRaw.maxBytesPerElement;
+        }
+    }
+    if (prefsRaw.maxBytesPerCard !== undefined) {
+        if (!isNumber(prefsRaw.maxBytesPerCard) || prefsRaw.maxBytesPerCard < preferences.maxBytesPerElement) {
+            errors.push("preferences.maxBytesPerCard must be a number >= maxBytesPerElement");
+        }
+        else {
+            preferences.maxBytesPerCard = prefsRaw.maxBytesPerCard;
+        }
+    }
+    const limitsRaw = isObject(raw.globalLimits) ? raw.globalLimits : {};
+    const globalLimits = { ...DEFAULT_GLOBAL_LIMITS };
+    if (limitsRaw.maxConcurrentRuns !== undefined) {
+        if (!isNumber(limitsRaw.maxConcurrentRuns) || limitsRaw.maxConcurrentRuns < 1) {
+            errors.push("globalLimits.maxConcurrentRuns must be a number >= 1");
+        }
+        else {
+            globalLimits.maxConcurrentRuns = limitsRaw.maxConcurrentRuns;
+        }
+    }
+    if (errors.length > 0)
+        return { ok: false, errors };
+    const config = {
+        version: 1,
+        app: {
+            appId: app.appId.trim(),
+            ownerOpenId: app.ownerOpenId.trim(),
+            encryptCheck: app.encryptCheck,
+            secretRef: secretRef,
+        },
+        preferences,
+        globalLimits,
+    };
+    return { ok: true, value: config, errors: [] };
+}
+export function validateScopesFile(raw) {
+    const errors = [];
+    if (!isObject(raw)) {
+        return { ok: false, errors: ["scopes file must be an object"] };
+    }
+    if (raw.version !== 1)
+        errors.push(`scopes.version must be 1 (got ${String(raw.version)})`);
+    const scopes = raw.scopes;
+    if (!isObject(scopes)) {
+        errors.push("scopes.scopes must be an object");
+        return { ok: false, errors };
+    }
+    const out = {};
+    for (const [chatId, value] of Object.entries(scopes)) {
+        const { ok, value: scope, errors: scopeErrs } = validateScopeConfig(value);
+        if (!ok || !scope) {
+            for (const e of scopeErrs)
+                errors.push(`scopes[${chatId}]: ${e}`);
+            continue;
+        }
+        out[chatId] = scope;
+    }
+    if (errors.length > 0)
+        return { ok: false, errors };
+    return { ok: true, value: { version: 1, scopes: out }, errors: [] };
+}
+export function validateScopeConfig(raw) {
+    const errors = [];
+    if (!isObject(raw))
+        return { ok: false, errors: ["scope must be an object"] };
+    if (!isString(raw.cwd) || !raw.cwd.trim())
+        errors.push("cwd required");
+    if (!isString(raw.displayName) || !raw.displayName.trim())
+        errors.push("displayName required");
+    if (!isStringArray(raw.allowedUsers))
+        errors.push("allowedUsers must be string[]");
+    else if (raw.allowedUsers.length === 0)
+        errors.push("allowedUsers must be non-empty");
+    if (!isStringArray(raw.admins))
+        errors.push("admins must be string[]");
+    if (!isString(raw.defaultPermissionMode) || !PERMISSION_MODES.includes(raw.defaultPermissionMode)) {
+        errors.push(`defaultPermissionMode must be one of ${PERMISSION_MODES.join("|")}`);
+    }
+    if (raw.model !== null && !isString(raw.model))
+        errors.push("model must be string|null");
+    if (!isNumber(raw.createdAt))
+        errors.push("createdAt must be number");
+    if (!isNumber(raw.lastActiveAt))
+        errors.push("lastActiveAt must be number");
+    if (errors.length > 0)
+        return { ok: false, errors };
+    return {
+        ok: true,
+        value: {
+            cwd: raw.cwd.trim(),
+            displayName: raw.displayName.trim(),
+            allowedUsers: raw.allowedUsers,
+            admins: raw.admins,
+            defaultPermissionMode: raw.defaultPermissionMode,
+            model: raw.model,
+            createdAt: raw.createdAt,
+            lastActiveAt: raw.lastActiveAt,
+        },
+        errors: [],
+    };
+}
+export function validateSessionsFile(raw) {
+    const errors = [];
+    if (!isObject(raw))
+        return { ok: false, errors: ["sessions file must be an object"] };
+    if (raw.version !== 1)
+        errors.push(`sessions.version must be 1 (got ${String(raw.version)})`);
+    const sessions = raw.sessions;
+    if (!isObject(sessions)) {
+        errors.push("sessions.sessions must be an object");
+        return { ok: false, errors };
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(sessions)) {
+        const { ok, value: entry, errors: entryErrs } = validateSessionEntry(value);
+        if (!ok || !entry) {
+            for (const e of entryErrs)
+                errors.push(`sessions[${key}]: ${e}`);
+            continue;
+        }
+        out[key] = entry;
+    }
+    if (errors.length > 0)
+        return { ok: false, errors };
+    return { ok: true, value: { version: 1, sessions: out }, errors: [] };
+}
+export function validateSessionEntry(raw) {
+    const errors = [];
+    if (!isObject(raw))
+        return { ok: false, errors: ["session entry must be an object"] };
+    if (!isString(raw.sessionFile) || !raw.sessionFile)
+        errors.push("sessionFile required");
+    if (!isString(raw.cwd) || !raw.cwd)
+        errors.push("cwd required");
+    if (!isString(raw.permissionMode) || !PERMISSION_MODES.includes(raw.permissionMode)) {
+        errors.push(`permissionMode must be one of ${PERMISSION_MODES.join("|")}`);
+    }
+    if (!isNumber(raw.lastActiveAt))
+        errors.push("lastActiveAt must be number");
+    if (errors.length > 0)
+        return { ok: false, errors };
+    return {
+        ok: true,
+        value: {
+            sessionFile: raw.sessionFile,
+            cwd: raw.cwd,
+            permissionMode: raw.permissionMode,
+            lastActiveAt: raw.lastActiveAt,
+        },
+        errors: [],
+    };
+}

package/dist/feishu/scope/scope-registry.d.ts

@@ -0,0 +1,39 @@
+/**
+ * scopes.json reader/writer.
+ *
+ * `cwd` here is the *initial* cwd written by the wizard. The truth source
+ * for "current cwd" after first use is sessions.json. See SessionStore.
+ *
+ * `/feishu bind` is invoked from the TUI process, but the running serve
+ * is a separate spawned subprocess — so the serve's in-memory cache would
+ * go stale the moment the TUI updates scopes.json. To bridge that, every
+ * read path stats the file and reloads if its mtime is newer than what
+ * we have cached. The cost is one stat() call per inbound message, which
+ * is negligible compared to LLM latency.
+ */
+import type { ScopeConfig, ScopesFile } from "../types.js";
+export declare class ScopeRegistry {
+    private file;
+    private lastMtimeMs;
+    constructor(file: ScopesFile, mtimeMs: number);
+    static load(): ScopeRegistry;
+    /**
+     * Reload from disk if scopes.json has been modified since our cached copy.
+     * Called from every read path so cross-process writes (e.g. `/feishu bind`
+     * from the TUI updating the file while the serve subprocess is running)
+     * become visible without restart.
+     */
+    private syncFromDiskIfChanged;
+    save(): void;
+    get(chatId: string): ScopeConfig | undefined;
+    has(chatId: string): boolean;
+    list(): Array<{
+        chatId: string;
+        scope: ScopeConfig;
+    }>;
+    upsert(chatId: string, scope: ScopeConfig): void;
+    remove(chatId: string): boolean;
+    touch(chatId: string, when?: number): void;
+    isUserAllowed(chatId: string, userId: string): boolean;
+    isUserAdmin(chatId: string, userId: string): boolean;
+}