@kernel.chat/kbot 3.99.30 → 3.99.33

package/dist/channels/office.js

@@ -0,0 +1,169 @@
+// Microsoft Office channel adapter — drives Word, Excel, PowerPoint via the
+// Microsoft Graph API. Mirrors Microsoft's Copilot Agent Mode (GA April 22,
+// 2026) but lets kbot orchestrate the same operations from the terminal.
+//
+// Auth: bearer token in MICROSOFT_GRAPH_TOKEN. Acquire via the Microsoft
+// identity platform (delegated permissions: Files.ReadWrite, Sites.ReadWrite.All).
+//
+// The standard ChannelAdapter interface is preserved:
+//   - send       → POST a comment on a drive item (file)
+//   - receive    → list comments on a drive item
+//   - listChannels → enumerate drive root children (folders/files)
+//
+// Office-specific operations are exposed as additional methods on the class:
+//   - listFiles, readDocument, writeDocumentSection,
+//     appendToWorkbook, addSlide
+const GRAPH_BASE = 'https://graph.microsoft.com/v1.0';
+function getToken() {
+    const token = process.env.MICROSOFT_GRAPH_TOKEN;
+    if (!token) {
+        throw new Error('MICROSOFT_GRAPH_TOKEN is not set — Microsoft Office adapter cannot authenticate');
+    }
+    return token;
+}
+async function graphFetch(path, init = {}) {
+    const token = getToken();
+    const headers = {
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/json',
+        ...(init.headers ?? {}),
+    };
+    if (init.body !== undefined && !headers['Content-Type'] && !init.rawBody) {
+        headers['Content-Type'] = 'application/json';
+    }
+    const url = path.startsWith('http') ? path : `${GRAPH_BASE}${path}`;
+    const res = await fetch(url, { ...init, headers });
+    if (!res.ok) {
+        let bodyText = '';
+        try {
+            bodyText = await res.text();
+        }
+        catch {
+            // ignore body decode errors
+        }
+        throw new Error(`Microsoft Graph ${init.method ?? 'GET'} ${path} failed: ${res.status} ${res.statusText}${bodyText ? ` — ${bodyText}` : ''}`);
+    }
+    if (res.status === 204)
+        return undefined;
+    const contentType = res.headers.get('content-type') ?? '';
+    if (contentType.includes('application/json')) {
+        return (await res.json());
+    }
+    // Raw body — return as text. Callers casting to T accept the contract.
+    return (await res.text());
+}
+function commentToChannelMessage(c) {
+    const text = c.content?.content ?? '';
+    const ts = c.createdDateTime ? Date.parse(c.createdDateTime) : Date.now();
+    return {
+        id: c.id,
+        from: c.from?.user?.displayName ?? c.from?.user?.id ?? 'unknown',
+        text,
+        ts: Number.isNaN(ts) ? Date.now() : ts,
+        raw: c,
+    };
+}
+export class OfficeChannel {
+    name = 'office';
+    isConfigured() {
+        return Boolean(process.env.MICROSOFT_GRAPH_TOKEN);
+    }
+    /** Post a comment to a drive item (file). `envelope.channel` is the fileId. */
+    async send(envelope) {
+        const fileId = envelope.channel;
+        const json = await graphFetch(`/me/drive/items/${encodeURIComponent(fileId)}/comments`, {
+            method: 'POST',
+            body: JSON.stringify({ message: envelope.text }),
+        });
+        const ts = json.createdDateTime ? Date.parse(json.createdDateTime) : Date.now();
+        return { id: json.id ?? '', ts: Number.isNaN(ts) ? Date.now() : ts };
+    }
+    /** List comments on a drive item. `opts.channel` is the fileId. */
+    async receive(opts) {
+        const limit = opts.limit ?? 100;
+        const json = await graphFetch(`/me/drive/items/${encodeURIComponent(opts.channel)}/comments?$top=${limit}`);
+        const items = (json.value ?? []).map(commentToChannelMessage);
+        if (opts.oldest !== undefined) {
+            return items.filter((m) => m.ts > opts.oldest);
+        }
+        return items;
+    }
+    /** List drive root children. */
+    async listChannels() {
+        const items = await this.listFiles({});
+        return items.map((it) => ({
+            id: it.id,
+            name: it.name ?? it.id,
+            topic: it.file?.mimeType ?? (it.folder ? 'folder' : undefined),
+        }));
+    }
+    // ---------- Office-specific operations ----------
+    async listFiles(options = {}) {
+        let path;
+        if (options.driveId && options.folderId) {
+            path = `/drives/${encodeURIComponent(options.driveId)}/items/${encodeURIComponent(options.folderId)}/children`;
+        }
+        else if (options.driveId) {
+            path = `/drives/${encodeURIComponent(options.driveId)}/root/children`;
+        }
+        else if (options.folderId) {
+            path = `/me/drive/items/${encodeURIComponent(options.folderId)}/children`;
+        }
+        else {
+            path = '/me/drive/root/children';
+        }
+        const json = await graphFetch(path);
+        return json.value ?? [];
+    }
+    async readDocument(options) {
+        const { fileId, format = 'raw' } = options;
+        if (format === 'worksheets') {
+            const json = await graphFetch(`/me/drive/items/${encodeURIComponent(fileId)}/workbook/worksheets`);
+            return json.value ?? [];
+        }
+        return graphFetch(`/me/drive/items/${encodeURIComponent(fileId)}/content`, {
+            method: 'GET',
+            rawBody: true,
+        });
+    }
+    /**
+     * Replace an entire Word document with `content`.
+     *
+     * TODO(office-add-in): For surgical, paragraph- or range-level edits, route
+     * through an Office Add-in's `Word.Range` API (Word JavaScript API). The
+     * Graph REST surface does not expose Word ranges directly; the standard
+     * workaround is the Office Add-in JS bridge.
+     */
+    async writeDocumentSection(options) {
+        const { fileId, content } = options;
+        const body = typeof content === 'string' ? new TextEncoder().encode(content) : content;
+        const json = await graphFetch(`/me/drive/items/${encodeURIComponent(fileId)}/content`, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/octet-stream' },
+            body: body,
+            rawBody: true,
+        });
+        return { id: json.id, size: json.size };
+    }
+    async appendToWorkbook(options) {
+        const { fileId, sheet, rows, table = 'Table1' } = options;
+        const path = `/me/drive/items/${encodeURIComponent(fileId)}/workbook/worksheets/` +
+            `${encodeURIComponent(sheet)}/tables/${encodeURIComponent(table)}/rows/add`;
+        return graphFetch(path, {
+            method: 'POST',
+            body: JSON.stringify({ values: rows }),
+        });
+    }
+    /**
+     * TODO(pptx): Microsoft Graph does not expose slide-level mutation. The
+     * workaround is to regenerate the .pptx (e.g. via `pptxgenjs`) and PUT the
+     * bytes back via `/me/drive/items/{fileId}/content`. Until that dependency
+     * is wired, this method throws.
+     */
+    async addSlide(_options) {
+        throw new Error('addSlide requires pptx-genjs — see TODO in office.ts');
+    }
+}
+export const officeAdapter = new OfficeChannel();
+export default officeAdapter;
+//# sourceMappingURL=office.js.map

package/dist/channels/registry.d.ts

@@ -0,0 +1,8 @@
+import type { ChannelAdapter } from './types.js';
+export declare function getChannel(name: string): ChannelAdapter;
+export declare function listChannels(): Array<{
+    name: string;
+    configured: boolean;
+}>;
+export declare function registerChannel(adapter: ChannelAdapter): void;
+//# sourceMappingURL=registry.d.ts.map

package/dist/channels/registry.js

@@ -0,0 +1,38 @@
+// Registry for messaging channel adapters.
+//
+// Consumers should call `getChannel(name)` rather than importing adapters
+// directly; this lets the registry be replaced or extended (e.g. a plugin
+// registering an Instagram adapter at runtime).
+import { slackAdapter } from './slack.js';
+import { whatsappAdapter } from './whatsapp.js';
+import { telegramAdapter } from './telegram.js';
+import { signalAdapter } from './signal.js';
+import { matrixAdapter } from './matrix.js';
+import { teamsAdapter } from './teams.js';
+import { officeAdapter } from './office.js';
+const adapters = {
+    slack: slackAdapter,
+    whatsapp: whatsappAdapter,
+    telegram: telegramAdapter,
+    signal: signalAdapter,
+    matrix: matrixAdapter,
+    teams: teamsAdapter,
+    office: officeAdapter,
+};
+export function getChannel(name) {
+    const adapter = adapters[name.toLowerCase()];
+    if (!adapter) {
+        throw new Error(`Unknown channel "${name}". Available: ${Object.keys(adapters).join(', ')}`);
+    }
+    return adapter;
+}
+export function listChannels() {
+    return Object.values(adapters).map((a) => ({
+        name: a.name,
+        configured: a.isConfigured(),
+    }));
+}
+export function registerChannel(adapter) {
+    adapters[adapter.name.toLowerCase()] = adapter;
+}
+//# sourceMappingURL=registry.js.map

package/dist/channels/signal.d.ts

@@ -0,0 +1,4 @@
+import { type ChannelAdapter } from './types.js';
+export declare const signalAdapter: ChannelAdapter;
+export default signalAdapter;
+//# sourceMappingURL=signal.d.ts.map

package/dist/channels/signal.js

@@ -0,0 +1,29 @@
+// Signal channel adapter — STUB.
+//
+// TODO: Implement against signal-cli.
+//   - Auth: SIGNAL_CLI_PATH env var pointing at the signal-cli binary.
+//   - SIGNAL_ACCOUNT env var = the registered E.164 number.
+//   - send → spawn `${SIGNAL_CLI_PATH} -a ${SIGNAL_ACCOUNT} send -m <text> <recipient>`
+//     (or use signal-cli's JSON-RPC mode for long-running processes).
+//   - receive → `signal-cli ... receive --json`, parse JSONL into
+//     ChannelMessage records.
+//   - listChannels → `signal-cli listGroups -d` for groups; contacts via
+//     `listContacts` if needed.
+import { ChannelNotImplementedError } from './types.js';
+export const signalAdapter = {
+    name: 'signal',
+    isConfigured() {
+        return Boolean(process.env.SIGNAL_CLI_PATH);
+    },
+    async send() {
+        throw new ChannelNotImplementedError('signal');
+    },
+    async receive() {
+        throw new ChannelNotImplementedError('signal');
+    },
+    async listChannels() {
+        throw new ChannelNotImplementedError('signal');
+    },
+};
+export default signalAdapter;
+//# sourceMappingURL=signal.js.map

package/dist/channels/slack.d.ts

@@ -0,0 +1,4 @@
+import type { ChannelAdapter } from './types.js';
+export declare const slackAdapter: ChannelAdapter;
+export default slackAdapter;
+//# sourceMappingURL=slack.d.ts.map

package/dist/channels/slack.js

@@ -0,0 +1,97 @@
+// Slack channel adapter.
+//
+// Uses the Slack Web API directly via `fetch` — no SDK dependency.
+// Token: SLACK_BOT_TOKEN (xoxb-…) with at minimum chat:write,
+// channels:history, channels:read, groups:read scopes.
+const SLACK_API = 'https://slack.com/api';
+function getToken() {
+    const token = process.env.SLACK_BOT_TOKEN;
+    if (!token) {
+        throw new Error('SLACK_BOT_TOKEN is not set — Slack adapter cannot authenticate');
+    }
+    return token;
+}
+async function slackFetch(path, body, token) {
+    const res = await fetch(`${SLACK_API}/${path}`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json; charset=utf-8',
+        },
+        body: JSON.stringify(body),
+    });
+    // Slack always returns 200 with `ok` flag in the body, but guard anyway.
+    if (!res.ok) {
+        throw new Error(`Slack API ${path} HTTP ${res.status}: ${res.statusText}`);
+    }
+    const json = (await res.json());
+    if (!json.ok) {
+        throw new Error(`Slack API ${path} error: ${json.error ?? 'unknown_error'}`);
+    }
+    return json;
+}
+function tsToMs(ts) {
+    if (!ts)
+        return Date.now();
+    // Slack `ts` is a string like "1700000000.000123" (seconds.microseconds).
+    const n = Number.parseFloat(ts);
+    if (Number.isNaN(n))
+        return Date.now();
+    return Math.round(n * 1000);
+}
+function msToTs(ms) {
+    if (ms === undefined)
+        return undefined;
+    return (ms / 1000).toFixed(6);
+}
+export const slackAdapter = {
+    name: 'slack',
+    isConfigured() {
+        return Boolean(process.env.SLACK_BOT_TOKEN);
+    },
+    async send(envelope) {
+        const token = getToken();
+        const body = {
+            channel: envelope.channel,
+            text: envelope.text,
+        };
+        if (envelope.blocks !== undefined)
+            body.blocks = envelope.blocks;
+        if (envelope.options)
+            Object.assign(body, envelope.options);
+        const json = await slackFetch('chat.postMessage', body, token);
+        const ts = json.ts ?? json.message?.ts;
+        return { id: ts ?? '', ts: tsToMs(ts) };
+    },
+    async receive(opts) {
+        const token = getToken();
+        const body = {
+            channel: opts.channel,
+            limit: opts.limit ?? 100,
+        };
+        const oldest = msToTs(opts.oldest);
+        if (oldest)
+            body.oldest = oldest;
+        const json = await slackFetch('conversations.history', body, token);
+        const messages = json.messages ?? [];
+        return messages.map((m) => ({
+            id: m.ts,
+            from: m.user ?? m.username ?? m.bot_id ?? 'unknown',
+            text: m.text ?? '',
+            ts: tsToMs(m.ts),
+            raw: m,
+        }));
+    },
+    async listChannels() {
+        const token = getToken();
+        const json = await slackFetch('conversations.list', { exclude_archived: true, limit: 200 }, token);
+        const channels = json.channels ?? [];
+        return channels.map((c) => ({
+            id: c.id,
+            name: c.name ?? c.id,
+            topic: c.topic?.value,
+        }));
+    },
+};
+export default slackAdapter;
+//# sourceMappingURL=slack.js.map

package/dist/channels/teams.d.ts

@@ -0,0 +1,4 @@
+import { type ChannelAdapter } from './types.js';
+export declare const teamsAdapter: ChannelAdapter;
+export default teamsAdapter;
+//# sourceMappingURL=teams.d.ts.map

package/dist/channels/teams.js

@@ -0,0 +1,29 @@
+// Microsoft Teams channel adapter — STUB.
+//
+// TODO: Implement against either:
+//   (a) Incoming Webhook (simple, send-only):
+//       MICROSOFT_TEAMS_WEBHOOK = https://outlook.office.com/webhook/...
+//       send → POST JSON Adaptive Card or MessageCard to the webhook URL.
+//       receive/listChannels → unsupported via webhook; surface a clear
+//       error pointing the caller at Graph API.
+//   (b) Microsoft Graph API (full duplex):
+//       requires app registration in Azure AD, delegated/application
+//       permissions, and an OAuth2 token. Out of scope for the stub.
+import { ChannelNotImplementedError } from './types.js';
+export const teamsAdapter = {
+    name: 'teams',
+    isConfigured() {
+        return Boolean(process.env.MICROSOFT_TEAMS_WEBHOOK);
+    },
+    async send() {
+        throw new ChannelNotImplementedError('teams');
+    },
+    async receive() {
+        throw new ChannelNotImplementedError('teams');
+    },
+    async listChannels() {
+        throw new ChannelNotImplementedError('teams');
+    },
+};
+export default teamsAdapter;
+//# sourceMappingURL=teams.js.map

package/dist/channels/telegram.d.ts

@@ -0,0 +1,4 @@
+import { type ChannelAdapter } from './types.js';
+export declare const telegramAdapter: ChannelAdapter;
+export default telegramAdapter;
+//# sourceMappingURL=telegram.d.ts.map

package/dist/channels/telegram.js

@@ -0,0 +1,28 @@
+// Telegram channel adapter — STUB.
+//
+// TODO: Implement against the Telegram Bot API.
+//   - Auth: TELEGRAM_BOT_TOKEN (from @BotFather).
+//   - send → POST https://api.telegram.org/bot{token}/sendMessage
+//     body: { chat_id, text, parse_mode?, reply_markup? }
+//   - receive → either long-poll via getUpdates (simple) or webhook
+//     (production). Translate `update.message` into ChannelMessage.
+//   - listChannels → Telegram has no enumeration API; surface chats from
+//     a local persisted cache built from received updates.
+import { ChannelNotImplementedError } from './types.js';
+export const telegramAdapter = {
+    name: 'telegram',
+    isConfigured() {
+        return Boolean(process.env.TELEGRAM_BOT_TOKEN);
+    },
+    async send() {
+        throw new ChannelNotImplementedError('telegram');
+    },
+    async receive() {
+        throw new ChannelNotImplementedError('telegram');
+    },
+    async listChannels() {
+        throw new ChannelNotImplementedError('telegram');
+    },
+};
+export default telegramAdapter;
+//# sourceMappingURL=telegram.js.map

package/dist/channels/types.d.ts

@@ -0,0 +1,50 @@
+export interface ChannelMessage {
+    /** Channel-native message id (string-form). */
+    id: string;
+    /** Author handle / user id reported by the channel. */
+    from: string;
+    /** Plain-text body of the message. */
+    text: string;
+    /** Unix epoch ms. Channels that report seconds should multiply by 1000. */
+    ts: number;
+    /** Raw, channel-specific payload — adapter consumers may inspect. */
+    raw?: unknown;
+}
+export interface ChannelEnvelope {
+    /** Target channel id (Slack channel id, chat id, room id, ...). */
+    channel: string;
+    /** Plain-text body. Required even when blocks are supplied. */
+    text: string;
+    /** Optional rich content. Slack blocks, Telegram entities, etc. */
+    blocks?: unknown;
+    /** Adapter-specific options forwarded verbatim. */
+    options?: Record<string, unknown>;
+}
+export interface ChannelReceiveOptions {
+    channel: string;
+    /** Unix epoch ms; only return messages newer than this. */
+    oldest?: number;
+    /** Maximum number of messages to return (adapter may cap). */
+    limit?: number;
+}
+export interface ChannelInfo {
+    id: string;
+    name: string;
+    topic?: string;
+}
+export interface ChannelAdapter {
+    /** Stable adapter name — must match registry key. */
+    readonly name: string;
+    /** True when required env vars / credentials are present. */
+    isConfigured(): boolean;
+    send(envelope: ChannelEnvelope): Promise<{
+        id: string;
+        ts: number;
+    }>;
+    receive(opts: ChannelReceiveOptions): Promise<ChannelMessage[]>;
+    listChannels(): Promise<ChannelInfo[]>;
+}
+export declare class ChannelNotImplementedError extends Error {
+    constructor(adapter: string);
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/channels/types.js

@@ -0,0 +1,13 @@
+// Shared types for the unified messaging-channel adapter family.
+//
+// Inspired by OpenClaw (steipete/openclaw on npm). Every channel adapter
+// (Slack, WhatsApp, Telegram, Signal, Matrix, Teams, ...) implements
+// the same `ChannelAdapter` interface so kbot tools and agents can
+// send/receive messages without caring which platform they target.
+export class ChannelNotImplementedError extends Error {
+    constructor(adapter) {
+        super(`${adapter} adapter not implemented yet — see TODO in channels/${adapter}.ts`);
+        this.name = 'ChannelNotImplementedError';
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/channels/whatsapp.d.ts

@@ -0,0 +1,4 @@
+import { type ChannelAdapter } from './types.js';
+export declare const whatsappAdapter: ChannelAdapter;
+export default whatsappAdapter;
+//# sourceMappingURL=whatsapp.d.ts.map

package/dist/channels/whatsapp.js

@@ -0,0 +1,28 @@
+// WhatsApp channel adapter — STUB.
+//
+// TODO: Implement against WhatsApp Business Cloud API.
+//   - Auth: Bearer token from Meta for Developers (`WHATSAPP_BUSINESS_TOKEN`).
+//   - Phone number id: WHATSAPP_PHONE_NUMBER_ID
+//   - send → POST https://graph.facebook.com/v20.0/{phone-id}/messages
+//   - receive → webhook subscription; this adapter would surface messages
+//     queued by the webhook receiver, not poll.
+//   - listChannels → WhatsApp does not have channels; return contacts/groups
+//     resolved via the Cloud API or a local cache.
+import { ChannelNotImplementedError } from './types.js';
+export const whatsappAdapter = {
+    name: 'whatsapp',
+    isConfigured() {
+        return Boolean(process.env.WHATSAPP_BUSINESS_TOKEN && process.env.WHATSAPP_PHONE_NUMBER_ID);
+    },
+    async send() {
+        throw new ChannelNotImplementedError('whatsapp');
+    },
+    async receive() {
+        throw new ChannelNotImplementedError('whatsapp');
+    },
+    async listChannels() {
+        throw new ChannelNotImplementedError('whatsapp');
+    },
+};
+export default whatsappAdapter;
+//# sourceMappingURL=whatsapp.js.map

package/dist/computer-use-coordinator.d.ts

@@ -0,0 +1,44 @@
+export interface AgentRegistration {
+    apps: string[];
+    windowIds?: string[];
+}
+export interface LockRecord {
+    agentId: string;
+    pid: number;
+    ts: number;
+    windowIds?: string[];
+}
+export interface ClaimResult {
+    granted: boolean;
+    app: string;
+    heldBy?: string;
+    since?: number;
+}
+export interface CoordinatorStatus {
+    apps: Record<string, {
+        heldBy: string;
+        since: number;
+    } | null>;
+    agents: Array<{
+        id: string;
+        apps: string[];
+        claimed: string[];
+    }>;
+}
+export declare class Coordinator {
+    private root;
+    private agents;
+    /** in-memory mirror of which apps this coordinator instance has claimed */
+    private claimed;
+    constructor(root?: string);
+    private lockPath;
+    private readLock;
+    private isStale;
+    register(agentId: string, reg: AgentRegistration): void;
+    claim(agentId: string, app: string): ClaimResult;
+    release(agentId: string, app: string): boolean;
+    unregister(agentId: string): string[];
+    status(): CoordinatorStatus;
+}
+export declare function createCoordinator(root?: string): Coordinator;
+//# sourceMappingURL=computer-use-coordinator.d.ts.map

package/dist/doctor.js

@@ -164,7 +164,7 @@ async function checkLocalProviderReachable(providerId, providerConfig) {
         else {
             checkUrl = providerConfig.apiUrl.replace('/v1/chat/completions', '/v1/models');
         }
-        const res = await fetch(checkUrl, { signal: AbortSignal.timeout(3000) });
+        const res = await fetch(checkUrl, { signal: AbortSignal.timeout(5000) });
         if (!res.ok) {
             return { name: providerConfig.name, status: 'fail', message: `returned ${res.status}` };
         }
@@ -194,8 +194,11 @@ async function checkLocalProviderReachable(providerId, providerConfig) {
         }
         return { name: providerConfig.name, status: 'pass', message: 'running' };
     }
-    catch {
-        return { name: providerConfig.name, status: 'fail', message: 'not responding' };
+    catch (err) {
+        const reason = err instanceof Error
+            ? (err.name === 'TimeoutError' ? 'timed out (>5s)' : err.message)
+            : 'not responding';
+        return { name: providerConfig.name, status: 'fail', message: reason };
     }
 }
 /**

package/dist/file-library.d.ts

@@ -0,0 +1,76 @@
+/**
+ * File Library — local-first per-user file store.
+ *
+ * Mirrors ChatGPT's File Library: auto-saves uploaded and created files,
+ * lists, searches by name/content, fetches by id. Content-addressed (sha256).
+ *
+ * Storage layout:
+ *   <root>/index.json           — atomic JSON index of entries
+ *   <root>/blobs/<id>           — raw file bytes (id = sha256 of contents)
+ *
+ * Default root: ~/.kbot/files (overridable via KBOT_FILE_LIBRARY_ROOT or ctor opt).
+ */
+export declare const MAX_FILE_BYTES: number;
+export type FileSource = "user-upload" | "agent-output" | "tool-output";
+export interface FileEntry {
+    id: string;
+    name: string;
+    mimeType: string;
+    size: number;
+    createdAt: string;
+    source: FileSource;
+    tags: string[];
+    path: string;
+}
+export interface AddFileInput {
+    name: string;
+    mimeType: string;
+    source: FileSource;
+    content?: string;
+    buffer?: Buffer;
+    tags?: string[];
+}
+export interface ListOptions {
+    limit?: number;
+    since?: string | Date;
+    tag?: string;
+}
+export type SearchMode = "name" | "content" | "both";
+export interface SearchOptions {
+    query: string;
+    mode: SearchMode;
+}
+export interface FileLibraryOptions {
+    root?: string;
+}
+export declare class FileLibrary {
+    private readonly root;
+    private readonly blobsDir;
+    private readonly indexPath;
+    private writeLock;
+    constructor(opts?: FileLibraryOptions);
+    getRoot(): string;
+    private ensureDirs;
+    private readIndex;
+    /**
+     * Atomic write: serialize → write to <indexPath>.tmp.<rand> → rename.
+     */
+    private writeIndexAtomic;
+    /**
+     * Run a read-modify-write of the index under the writeLock so concurrent
+     * mutations don't lose updates. The mutator may return a fresh IndexFile
+     * (or undefined to skip the write).
+     */
+    private mutateIndex;
+    addFile(input: AddFileInput): Promise<FileEntry>;
+    listFiles(opts?: ListOptions): Promise<FileEntry[]>;
+    getFile(id: string): Promise<{
+        entry: FileEntry;
+        buffer: Buffer;
+    } | null>;
+    removeFile(id: string): Promise<boolean>;
+    searchFiles(opts: SearchOptions): Promise<FileEntry[]>;
+}
+export declare function getDefaultFileLibrary(): FileLibrary;
+export declare function _resetDefaultFileLibrary(): void;
+//# sourceMappingURL=file-library.d.ts.map