clearclaw 0.4.0 → 0.6.0

package/dist/channel/slack.d.ts

@@ -1,16 +1,18 @@
 import { EventEmitter } from "node:events";
-import type { Channel, Button, ButtonResponse, SendMessageOpts } from "../types.js";
+import type { Channel, Button, ButtonResponse, SendFileOpts, SendMessageOpts, UserInfo } from "../types.js";
 export declare class SlackChannel extends EventEmitter implements Channel {
     name: string;
+    private static readonly EMOJI_TO_SLACK;
     private app;
     private botToken;
     private botUserId;
-    private allowedUserIds;
+    private isAuthorized;
+    private onUnauthorizedDM?;
     private pendingButtonCallbacks;
     private pendingModalCallbacks;
     private typingMessageTs;
     private userNameCache;
-    constructor(botToken: string, appToken: string, allowedUserIds: Set<string>);
+    constructor(botToken: string, appToken: string, isAuthorized: (userId: string) => boolean, onUnauthorizedDM?: (chatId: string, user: UserInfo) => void);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     ownsId(chatId: string): boolean;
@@ -22,8 +24,12 @@ export declare class SlackChannel extends EventEmitter implements Channel {
     unpinAllMessages(chatId: string): Promise<void>;
     updateStatus(chatId: string, text: string): Promise<void>;
     setTyping(chatId: string, isTyping: boolean): Promise<void>;
+    sendFile(chatId: string, buffer: Buffer, filename: string, opts?: SendFileOpts): Promise<void>;
+    reactToMessage(chatId: string, messageId: string, emoji: string): Promise<void>;
     private slackId;
     /** Download a file from Slack using bot token auth. */
     private downloadFile;
     private resolveUserName;
+    /** Fetch the parent message of a thread reply for reply context. */
+    private fetchReplyContext;
 }

package/dist/channel/slack.js

@@ -1,20 +1,29 @@
 import { EventEmitter } from "node:events";
 import { App, LogLevel } from "@slack/bolt";
+import { slackifyMarkdown } from "slackify-markdown";
 import log from "../logger.js";
 export class SlackChannel extends EventEmitter {
     name = "slack";
+    static EMOJI_TO_SLACK = {
+        "👍": "+1", "👎": "-1", "❤️": "heart", "🔥": "fire",
+        "😂": "joy", "🎉": "tada", "✅": "white_check_mark", "🚀": "rocket",
+        "👀": "eyes", "💯": "100", "🤔": "thinking_face", "😮": "open_mouth",
+        "🙏": "pray", "💪": "muscle", "⚡": "zap", "🌟": "star2",
+    };
     app;
     botToken;
     botUserId;
-    allowedUserIds;
+    isAuthorized;
+    onUnauthorizedDM;
     pendingButtonCallbacks = new Map(); // actionId → resolve
     pendingModalCallbacks = new Map(); // modal callbackId → resolve
     typingMessageTs = new Map(); // chatId → ts of bot's "typing…" placeholder
     userNameCache = new Map();
-    constructor(botToken, appToken, allowedUserIds) {
+    constructor(botToken, appToken, isAuthorized, onUnauthorizedDM) {
         super();
         this.botToken = botToken;
-        this.allowedUserIds = allowedUserIds;
+        this.isAuthorized = isAuthorized;
+        this.onUnauthorizedDM = onUnauthorizedDM;
         this.app = new App({
             token: botToken, appToken, socketMode: true, logLevel: LogLevel.ERROR,
         });
@@ -44,9 +53,18 @@ export class SlackChannel extends EventEmitter {
             if (!msg.text && (!msg.files || msg.files.length === 0))
                 return;
             const userId = msg.user;
-            if (!userId || !this.allowedUserIds.has(`slack:${userId}`)) {
-                if (userId)
-                    log.info("[channel] ignored message from unauthorized user slack:%s", userId);
+            if (!userId)
+                return;
+            const prefixedId = `slack:${userId}`;
+            if (!this.isAuthorized(prefixedId)) {
+                // Slack DM channel IDs start with "D"
+                if (msg.channel.startsWith("D") && this.onUnauthorizedDM) {
+                    const userName = await this.resolveUserName(userId);
+                    this.onUnauthorizedDM(chatId, { id: prefixedId, name: userName ?? userId });
+                }
+                else {
+                    log.info("[channel] ignored message from unauthorized user %s", prefixedId);
+                }
                 return;
             }
             // Download attached files in parallel
@@ -70,11 +88,18 @@ export class SlackChannel extends EventEmitter {
                         attachments = succeeded;
                 }
             }
+            const replyTo = msg.thread_ts
+                ? await this.fetchReplyContext(msg.channel, msg.thread_ts, msg.ts)
+                : undefined;
+            const chatType = msg.channel.startsWith("D") ? "dm" : "group";
             const userName = await this.resolveUserName(userId);
             this.emit("message", {
                 chatId,
-                user: { id: `slack:${userId}`, name: userName ?? userId },
+                chatType,
+                user: { id: prefixedId, name: userName ?? userId },
                 text: msg.text ?? "",
+                messageId: msg.ts,
+                replyTo,
                 ...(attachments && { attachments }),
             });
         });
@@ -95,11 +120,13 @@ export class SlackChannel extends EventEmitter {
                 return;
             const chatId = `slack:${command.channel_id}`;
             const userId = command.user_id;
-            if (!this.allowedUserIds.has(`slack:${userId}`))
+            if (!this.isAuthorized(`slack:${userId}`))
                 return;
+            const chatType = command.channel_id.startsWith("D") ? "dm" : "group";
             const userName = await this.resolveUserName(userId);
             this.emit("message", {
                 chatId,
+                chatType,
                 user: { id: `slack:${userId}`, name: userName ?? userId },
                 text: `/${subcommand}`,
             });
@@ -140,8 +167,9 @@ export class SlackChannel extends EventEmitter {
         const channel = this.slackId(chatId);
         const chunks = splitMessage(text);
         const handles = [];
-        // If a typing placeholder exists, edit the first chunk into it instead of posting new
-        const consumeTyping = opts?.consumeTyping !== false;
+        const threadTs = opts?.replyToMessageId;
+        // Consume typing placeholder only when not posting as a thread reply
+        const consumeTyping = !threadTs && opts?.consumeTyping !== false;
         const typingTs = consumeTyping ? this.typingMessageTs.get(chatId) : undefined;
         if (typingTs && chunks.length > 0) {
             this.typingMessageTs.delete(chatId);
@@ -166,6 +194,7 @@ export class SlackChannel extends EventEmitter {
             const blocks = mrkdwnBlocks(chunk);
             const result = await this.app.client.chat.postMessage({
                 channel, text: chunk, blocks,
+                ...(threadTs && { thread_ts: threadTs }),
             });
             if (result.ts)
                 handles.push(result.ts);
@@ -344,6 +373,32 @@ export class SlackChannel extends EventEmitter {
             }
         }
     }
+    async sendFile(chatId, buffer, filename, opts) {
+        const channel = this.slackId(chatId);
+        await this.app.client.files.uploadV2({
+            channel_id: channel,
+            file: buffer,
+            filename,
+            initial_comment: opts?.caption,
+        });
+    }
+    async reactToMessage(chatId, messageId, emoji) {
+        const name = SlackChannel.EMOJI_TO_SLACK[emoji];
+        if (!name) {
+            log.warn("[channel] no Slack emoji name for %s, skipping reaction", emoji);
+            return;
+        }
+        try {
+            await this.app.client.reactions.add({
+                channel: this.slackId(chatId),
+                timestamp: messageId,
+                name,
+            });
+        }
+        catch (err) {
+            log.warn("[channel] failed to add reaction %s: %s", name, err instanceof Error ? err.message : String(err));
+        }
+    }
     slackId(chatId) {
         return chatId.replace(/^slack:/, "");
     }
@@ -371,9 +426,44 @@ export class SlackChannel extends EventEmitter {
             return undefined;
         }
     }
+    /** Fetch the parent message of a thread reply for reply context. */
+    async fetchReplyContext(channel, threadTs, ownTs) {
+        if (threadTs === ownTs)
+            return undefined;
+        try {
+            const result = await this.app.client.conversations.history({
+                channel,
+                latest: threadTs,
+                limit: 1,
+                inclusive: true,
+            });
+            const parent = result.messages?.[0];
+            if (!parent)
+                return undefined;
+            const senderName = parent.user ? await this.resolveUserName(parent.user) : undefined;
+            return {
+                messageId: threadTs,
+                senderName: senderName ?? parent.user,
+                text: parent.text,
+                mediaType: parent.files?.[0]?.mimetype,
+            };
+        }
+        catch (err) {
+            log.warn({ err }, "[channel] failed to fetch thread parent %s", threadTs);
+            return undefined;
+        }
+    }
 }
 function mrkdwnBlocks(text) {
-    return [{ type: "section", text: { type: "mrkdwn", text } }];
+    let rendered;
+    try {
+        rendered = slackifyMarkdown(text);
+    }
+    catch (err) {
+        log.warn({ err }, "[channel] slackifyMarkdown failed, sending raw text");
+        rendered = text;
+    }
+    return [{ type: "section", text: { type: "mrkdwn", text: rendered } }];
 }
 // Block Kit section.text has a 3000 char limit — the tightest Slack constraint.
 // We split at this limit so each chunk fits both the text fallback and the block.

package/dist/channel/telegram.d.ts

@@ -1,15 +1,16 @@
 import { EventEmitter } from "node:events";
-import type { Channel, Button, ButtonResponse, SendMessageOpts } from "../types.js";
+import type { Channel, Button, ButtonResponse, SendFileOpts, SendMessageOpts, UserInfo } from "../types.js";
 export declare class TelegramChannel extends EventEmitter implements Channel {
     name: string;
     private bot;
     private botToken;
-    private allowedUserIds;
+    private isAuthorized;
+    private onUnauthorizedDM?;
     private typingIntervals;
     private statusHandles;
     private pendingCallbacks;
     private pendingTextResolvers;
-    constructor(botToken: string, allowedUserIds: Set<string>);
+    constructor(botToken: string, isAuthorized: (userId: string) => boolean, onUnauthorizedDM?: (chatId: string, user: UserInfo) => void);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     ownsId(chatId: string): boolean;
@@ -21,10 +22,16 @@ export declare class TelegramChannel extends EventEmitter implements Channel {
     unpinAllMessages(chatId: string): Promise<void>;
     updateStatus(chatId: string, text: string): Promise<void>;
     setTyping(chatId: string, isTyping: boolean): Promise<void>;
+    /** Build user info from a grammY context (no auth check). */
+    private buildUserInfo;
     /** Extract auth-checked sender info from a grammY context. Returns null if unauthorized. */
     private extractSender;
+    /** Extract reply context from a Telegram message, if it's a reply. */
+    private extractReplyContext;
     /** Shared handler for photo/document messages: download, emit attachment or fallback. */
-    private handleMediaMessage;
+    private handleFileMessage;
+    sendFile(chatId: string, buffer: Buffer, filename: string, opts?: SendFileOpts): Promise<void>;
+    reactToMessage(chatId: string, messageId: string, emoji: string): Promise<void>;
     /** Download a Telegram file by file_id, returning the raw buffer. */
     private downloadFile;
     private numericId;

package/dist/channel/telegram.js

@@ -1,21 +1,25 @@
 import { EventEmitter } from "node:events";
-import { Bot, InlineKeyboard } from "grammy";
+import { Bot, InlineKeyboard, InputFile } from "grammy";
+import mime from "mime";
+import telegramifyMarkdown from "telegramify-markdown";
 import log from "../logger.js";
 export class TelegramChannel extends EventEmitter {
     name = "telegram";
     bot;
     botToken;
-    allowedUserIds;
+    isAuthorized;
+    onUnauthorizedDM;
     typingIntervals = new Map();
     statusHandles = new Map(); // chatId → message handle for pinned status
     // Pending interactive responses: callbackId → resolve function
     pendingCallbacks = new Map();
     // Pending text input: chatId → resolve function (for requestText follow-ups)
     pendingTextResolvers = new Map();
-    constructor(botToken, allowedUserIds) {
+    constructor(botToken, isAuthorized, onUnauthorizedDM) {
         super();
         this.botToken = botToken;
-        this.allowedUserIds = allowedUserIds;
+        this.isAuthorized = isAuthorized;
+        this.onUnauthorizedDM = onUnauthorizedDM;
         this.bot = new Bot(botToken);
     }
     async connect() {
@@ -30,7 +34,12 @@ export class TelegramChannel extends EventEmitter {
                 textResolver(ctx.message.text);
                 return;
             }
-            this.emit("message", { ...sender, text: ctx.message.text });
+            this.emit("message", {
+                ...sender,
+                text: ctx.message.text,
+                messageId: String(ctx.message.message_id),
+                replyTo: this.extractReplyContext(ctx.message),
+            });
         });
         // Photos: Telegram sends each photo as an array of PhotoSize objects
         // (same image at different resolutions, sorted smallest → largest).
@@ -38,12 +47,12 @@ export class TelegramChannel extends EventEmitter {
         this.bot.on("message:photo", async (ctx) => {
             const photo = ctx.message.photo;
             const largest = photo[photo.length - 1];
-            await this.handleMediaMessage(ctx, largest.file_id, "image/jpeg", undefined, ctx.message.caption);
+            await this.handleFileMessage(ctx, largest.file_id, "image/jpeg", undefined, ctx.message.caption);
         });
         // Documents: download with original MIME + filename
         this.bot.on("message:document", async (ctx) => {
             const doc = ctx.message.document;
-            await this.handleMediaMessage(ctx, doc.file_id, doc.mime_type ?? "application/octet-stream", doc.file_name, ctx.message.caption);
+            await this.handleFileMessage(ctx, doc.file_id, doc.mime_type ?? "application/octet-stream", doc.file_name, ctx.message.caption);
         });
         // Placeholder handlers for unsupported media types
         for (const [filter, label] of [
@@ -56,7 +65,12 @@ export class TelegramChannel extends EventEmitter {
                 const sender = this.extractSender(ctx);
                 if (!sender)
                     return;
-                this.emit("message", { ...sender, text: `[${label} — not supported]` });
+                this.emit("message", {
+                    ...sender,
+                    text: `[${label} — not supported]`,
+                    messageId: ctx.message ? String(ctx.message.message_id) : undefined,
+                    replyTo: ctx.message ? this.extractReplyContext(ctx.message) : undefined,
+                });
             });
         }
         // Handle inline keyboard button presses
@@ -96,23 +110,25 @@ export class TelegramChannel extends EventEmitter {
         const numId = this.numericId(chatId);
         const chunks = splitMessage(text);
         const handles = [];
+        let firstChunk = true;
         for (const chunk of chunks) {
+            const replyParams = firstChunk && opts?.replyToMessageId
+                ? { reply_parameters: { message_id: Number(opts.replyToMessageId) } }
+                : {};
+            const rendered = telegramifyMarkdown(chunk, "escape");
             try {
-                const sent = await this.bot.api.sendMessage(numId, chunk, {
-                    parse_mode: opts?.parseMode,
+                const sent = await this.bot.api.sendMessage(numId, rendered, {
+                    parse_mode: "MarkdownV2",
+                    ...replyParams,
                 });
                 handles.push(String(sent.message_id));
             }
             catch (err) {
-                if (opts?.parseMode) {
-                    log.warn("[channel] sendMessage failed with %s, retrying as plain text", opts.parseMode);
-                    const sent = await this.bot.api.sendMessage(numId, chunk);
-                    handles.push(String(sent.message_id));
-                }
-                else {
-                    throw err;
-                }
+                log.warn("[channel] sendMessage failed with MarkdownV2, retrying as plain text");
+                const sent = await this.bot.api.sendMessage(numId, chunk, replyParams);
+                handles.push(String(sent.message_id));
             }
+            firstChunk = false;
         }
         return handles;
     }
@@ -138,7 +154,7 @@ export class TelegramChannel extends EventEmitter {
             keyboard.row();
         }
         // Convert universal markdown to MarkdownV2, fall back to plain text on failure
-        const mdv2Text = convertToMarkdownV2(text);
+        const mdv2Text = telegramifyMarkdown(text, "escape");
         let sent;
         try {
             sent = await this.bot.api.sendMessage(numId, mdv2Text, {
@@ -269,29 +285,69 @@ export class TelegramChannel extends EventEmitter {
             }
         }
     }
+    /** Build user info from a grammY context (no auth check). */
+    buildUserInfo(ctx) {
+        if (!ctx.from?.id)
+            return null;
+        return {
+            id: `tg:${ctx.from.id}`,
+            name: [ctx.from.first_name, ctx.from.last_name].filter(Boolean).join(" "),
+            ...(ctx.from.username && { handle: ctx.from.username }),
+        };
+    }
     /** Extract auth-checked sender info from a grammY context. Returns null if unauthorized. */
     extractSender(ctx) {
-        if (!ctx.from?.id || !ctx.chat?.id || !this.allowedUserIds.has(`tg:${ctx.from.id}`))
+        const user = this.buildUserInfo(ctx);
+        if (!user || !ctx.chat?.id || !this.isAuthorized(user.id)) {
+            // Notify unauthorized DM senders with their user ID (for pairing)
+            if (user && ctx.chat?.type === "private" && this.onUnauthorizedDM) {
+                this.onUnauthorizedDM(`tg:${ctx.chat.id}`, user);
+            }
             return null;
+        }
         return {
             chatId: `tg:${ctx.chat.id}`,
-            user: {
-                id: `tg:${ctx.from.id}`,
-                name: [ctx.from.first_name, ctx.from.last_name].filter(Boolean).join(" "),
-                ...(ctx.from.username && { handle: ctx.from.username }),
-            },
+            chatType: ctx.chat.type === "private" ? "dm" : "group",
+            user,
+        };
+    }
+    /** Extract reply context from a Telegram message, if it's a reply. */
+    extractReplyContext(msg) {
+        const reply = msg.reply_to_message;
+        if (!reply)
+            return undefined;
+        const mediaType = reply.photo ? "photo"
+            : reply.document ? "document"
+                : reply.video ? "video"
+                    : reply.voice ? "voice"
+                        : reply.audio ? "audio"
+                            : reply.sticker ? "sticker"
+                                : reply.animation ? "animation"
+                                    : undefined;
+        const senderName = reply.from
+            ? [reply.from.first_name, reply.from.last_name].filter(Boolean).join(" ")
+            : undefined;
+        return {
+            messageId: String(reply.message_id),
+            senderName,
+            text: reply.text ?? reply.caption,
+            mediaType,
         };
     }
     /** Shared handler for photo/document messages: download, emit attachment or fallback. */
-    async handleMediaMessage(ctx, fileId, mimeType, filename, caption) {
+    async handleFileMessage(ctx, fileId, mimeType, filename, caption) {
         const sender = this.extractSender(ctx);
         if (!sender)
             return;
+        const messageId = ctx.message ? String(ctx.message.message_id) : undefined;
+        const replyTo = ctx.message ? this.extractReplyContext(ctx.message) : undefined;
         try {
             const buffer = await this.downloadFile(fileId);
             this.emit("message", {
                 ...sender,
                 text: caption ?? "",
+                messageId,
+                replyTo,
                 attachments: [{ buffer, mimeType, filename }],
             });
         }
@@ -302,9 +358,41 @@ export class TelegramChannel extends EventEmitter {
                 text: caption
                     ? `${caption}\n[File download failed: ${filename ?? mimeType}]`
                     : `[File download failed: ${filename ?? mimeType}]`,
+                messageId,
+                replyTo,
             });
         }
     }
+    async sendFile(chatId, buffer, filename, opts) {
+        const id = this.numericId(chatId);
+        const mimeType = opts?.mimeType ?? mime.getType(filename) ?? "application/octet-stream";
+        const file = new InputFile(buffer, filename);
+        const caption = opts?.caption;
+        if (mimeType.startsWith("image/")) {
+            await this.bot.api.sendPhoto(id, file, { caption });
+        }
+        else if (mimeType.startsWith("video/")) {
+            await this.bot.api.sendVideo(id, file, { caption });
+        }
+        else if (mimeType.startsWith("audio/")) {
+            await this.bot.api.sendAudio(id, file, { caption });
+        }
+        else {
+            await this.bot.api.sendDocument(id, file, { caption });
+        }
+    }
+    async reactToMessage(chatId, messageId, emoji) {
+        const numId = this.numericId(chatId);
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            await this.bot.api.setMessageReaction(numId, Number(messageId), [
+                { type: "emoji", emoji: emoji },
+            ]);
+        }
+        catch (err) {
+            log.warn("[channel] failed to set reaction on %s: %s", messageId, err instanceof Error ? err.message : String(err));
+        }
+    }
     /** Download a Telegram file by file_id, returning the raw buffer. */
     async downloadFile(fileId) {
         const file = await this.bot.api.getFile(fileId);
@@ -320,38 +408,6 @@ export class TelegramChannel extends EventEmitter {
         return Number(chatId.replace(/^tg:/, ""));
     }
 }
-/**
- * Escape for Telegram MarkdownV2.
- * Outside code blocks: all special chars. Inside: only backtick and backslash.
- */
-function escapeMarkdownV2(text, codeBlock = false) {
-    const pattern = codeBlock ? /[`\\]/g : /[_*\[\]()~`>#+\-=|{}.!\\]/g;
-    return text.replace(pattern, "\\$&");
-}
-/**
- * Convert universal markdown (with code fences) to Telegram MarkdownV2.
- * Handles code blocks specially: fence markers stay literal, inner content
- * only escapes ` and \, outer text gets full MarkdownV2 escaping.
- */
-function convertToMarkdownV2(markdown) {
-    const result = [];
-    let pos = 0;
-    const fenceRegex = /```(\w*)\n([\s\S]*?)```/g;
-    let match;
-    while ((match = fenceRegex.exec(markdown)) !== null) {
-        if (match.index > pos) {
-            result.push(escapeMarkdownV2(markdown.slice(pos, match.index)));
-        }
-        result.push("```" + match[1] + "\n");
-        result.push(escapeMarkdownV2(match[2], true));
-        result.push("```");
-        pos = match.index + match[0].length;
-    }
-    if (pos < markdown.length) {
-        result.push(escapeMarkdownV2(markdown.slice(pos)));
-    }
-    return result.join("");
-}
 const MAX_MSG_LEN = 4096;
 /** Split text into ≤4096-char chunks, preferring newline boundaries. */
 function splitMessage(text) {

package/dist/config.d.ts

@@ -1,4 +1,4 @@
-import type { PermissionMode } from "./types.js";
+import type { PermissionMode, Workspace } from "./types.js";
 export interface TelegramConfig {
     type: "telegram";
     botToken: string;
@@ -9,13 +9,60 @@ export interface SlackConfig {
     appToken: string;
 }
 export type ChannelConfig = TelegramConfig | SlackConfig;
-export interface Config {
-    channel: ChannelConfig;
-    allowedUserIds: Set<string>;
+export interface AuthorizedUser {
+    id: string;
+    name: string;
+    approvedAt: number;
+}
+export interface PendingPairing {
+    code: string;
+    userId: string;
+    userName: string;
+    chatId: string;
+    expiresAt: number;
+}
+export declare function resolveDataDir(): string;
+/**
+ * Unified config: env var resolution + persistent store backed by config.json.
+ *
+ * - `new Config(dataDir)` gives store access (read/write methods)
+ * - `config.resolve()` adds env var settings (channel, envUserIds, permissionMode)
+ *
+ * File is re-read on every store call (hot-reload without file watching).
+ * Writes use 0o600 permissions (file contains bot token).
+ */
+export declare class Config {
+    channel?: ChannelConfig;
     permissionMode: PermissionMode;
-    defaultPromptPath: string;
-    workspaceStorePath: string;
-    filesPath: string;
-    logPath: string;
+    private envUserIds;
+    readonly defaultPromptPath: string;
+    readonly filesPath: string;
+    readonly logPath: string;
+    private readonly dataDir;
+    private readonly filePath;
+    constructor();
+    /** Resolve channel + env vars. Throws if no channel config found. */
+    resolve(): this;
+    private read;
+    private write;
+    getChannel(): ChannelConfig | undefined;
+    setChannel(config: ChannelConfig): void;
+    hasUser(userId: string): boolean;
+    addUser(user: AuthorizedUser): void;
+    listUsers(): AuthorizedUser[];
+    /** env var IDs (in-memory) + pairing-approved users (hot-reload from disk) */
+    isAuthorized(userId: string): boolean;
+    createPairing(userId: string, userName: string, chatId: string): string;
+    consumePairing(code: string): PendingPairing | null;
+    private generateCode;
+    workspaceByChat(chatId: string): Workspace | undefined;
+    workspaceByName(name: string): Workspace | undefined;
+    upsertWorkspace(ws: Workspace): void;
+    setSession(name: string, sessionId: string): void;
+    clearSession(name: string): void;
+    setBehavior(name: string, behavior: "assistant" | "relay"): void;
+    ensureDefaultWorkspace(chatId: string): void;
+    /** Copy bundled skills from the repo's skills/ directory to the home workspace's .claude/skills/. */
+    syncSkills(): void;
+    approveUser(userId: string, userName: string, chatId: string): void;
 }
-export declare function loadConfig(): Config;