clearclaw 0.3.0 → 0.5.0

package/dist/channel/telegram.js

@@ -1,40 +1,65 @@
 import { EventEmitter } from "node:events";
-import { Bot, InlineKeyboard } from "grammy";
+import { Bot, InlineKeyboard, InputFile } from "grammy";
+import mime from "mime";
 import log from "../logger.js";
 export class TelegramChannel extends EventEmitter {
     name = "telegram";
     bot;
+    botToken;
     allowedUserIds;
     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) {
         super();
+        this.botToken = botToken;
         this.allowedUserIds = allowedUserIds;
         this.bot = new Bot(botToken);
     }
     async connect() {
-        // Auth check: only respond to allowed user
         this.bot.on("message:text", (ctx) => {
-            if (!ctx.from?.id || !this.allowedUserIds.has(`tg:${ctx.from.id}`))
+            const sender = this.extractSender(ctx);
+            if (!sender)
                 return;
-            const chatId = `tg:${ctx.chat.id}`;
             // Intercept for requestText follow-ups before emitting as a new message
-            const textResolver = this.pendingTextResolvers.get(chatId);
+            const textResolver = this.pendingTextResolvers.get(sender.chatId);
             if (textResolver) {
-                this.pendingTextResolvers.delete(chatId);
+                this.pendingTextResolvers.delete(sender.chatId);
                 textResolver(ctx.message.text);
                 return;
             }
-            const 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 }),
-            };
-            this.emit("message", { chatId, user, text: ctx.message.text });
+            this.emit("message", { ...sender, text: ctx.message.text });
+        });
+        // Photos: Telegram sends each photo as an array of PhotoSize objects
+        // (same image at different resolutions, sorted smallest → largest).
+        // We grab the last element for the highest resolution version.
+        this.bot.on("message:photo", async (ctx) => {
+            const photo = ctx.message.photo;
+            const largest = photo[photo.length - 1];
+            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.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 [
+            ["message:voice", "Voice message"],
+            ["message:audio", "Audio message"],
+            ["message:video", "Video"],
+            ["message:sticker", "Sticker"],
+        ]) {
+            this.bot.on(filter, (ctx) => {
+                const sender = this.extractSender(ctx);
+                if (!sender)
+                    return;
+                this.emit("message", { ...sender, text: `[${label} — not supported]` });
+            });
+        }
         // Handle inline keyboard button presses
         this.bot.on("callback_query:data", async (ctx) => {
             const data = ctx.callbackQuery.data;
@@ -62,6 +87,7 @@ export class TelegramChannel extends EventEmitter {
             clearInterval(interval);
         }
         this.typingIntervals.clear();
+        this.statusHandles.clear();
         await this.bot.stop();
     }
     ownsId(chatId) {
@@ -91,7 +117,7 @@ export class TelegramChannel extends EventEmitter {
         }
         return handles;
     }
-    async sendInteractive(chatId, text, buttons, opts) {
+    async sendInteractive(chatId, text, buttons) {
         const numId = this.numericId(chatId);
         const callbackId = crypto.randomUUID().slice(0, 8);
         // Pre-compute callback data keys (use flat index to avoid collisions when buttons share values)
@@ -112,45 +138,52 @@ export class TelegramChannel extends EventEmitter {
             }
             keyboard.row();
         }
+        // Convert universal markdown to MarkdownV2, fall back to plain text on failure
+        const mdv2Text = convertToMarkdownV2(text);
         let sent;
         try {
-            sent = await this.bot.api.sendMessage(numId, text, {
+            sent = await this.bot.api.sendMessage(numId, mdv2Text, {
                 reply_markup: keyboard,
-                ...(opts?.parseMode && { parse_mode: opts.parseMode }),
+                parse_mode: "MarkdownV2",
             });
         }
-        catch (err) {
-            if (opts?.parseMode) {
-                log.warn("[channel] sendInteractive failed with %s, retrying as plain text", opts.parseMode);
-                sent = await this.bot.api.sendMessage(numId, text, {
-                    reply_markup: keyboard,
-                });
-            }
-            else {
-                throw err;
-            }
+        catch {
+            log.warn("[channel] sendInteractive failed with MarkdownV2, retrying as plain text");
+            sent = await this.bot.api.sendMessage(numId, text, {
+                reply_markup: keyboard,
+            });
         }
         const cleanupAll = () => {
             for (const { cbData } of cbEntries) {
                 this.pendingCallbacks.delete(cbData);
             }
         };
-        // Wait for button press or timeout (30 minutes)
+        // Wait for button press (no timeout — matches CLI behavior)
         const pressed = await new Promise((resolve) => {
-            const timeout = setTimeout(() => {
-                cleanupAll();
-                resolve(null);
-            }, 30 * 60 * 1000);
             for (const { btn, cbData } of cbEntries) {
                 this.pendingCallbacks.set(cbData, () => {
-                    clearTimeout(timeout);
                     cleanupAll();
                     resolve(btn);
                 });
             }
         });
-        if (!pressed)
-            return { value: "" };
+        // Update keyboard to highlight the selected button (others become inert — no callbacks)
+        const feedbackKeyboard = new InlineKeyboard();
+        let entryIndex = 0;
+        for (const row of buttons) {
+            for (const button of row) {
+                const entry = cbEntries[entryIndex++];
+                const label = button === pressed ? `✅ ${button.label}` : button.label;
+                feedbackKeyboard.text(label, entry.cbData);
+            }
+            feedbackKeyboard.row();
+        }
+        try {
+            await this.bot.api.editMessageReplyMarkup(numId, sent.message_id, {
+                reply_markup: feedbackKeyboard,
+            });
+        }
+        catch { /* best-effort */ }
         // If the button requests text, prompt for follow-up input
         if (pressed.requestText) {
             await this.bot.api.sendMessage(numId, "Add your feedback:", {
@@ -182,6 +215,39 @@ export class TelegramChannel extends EventEmitter {
         const numId = this.numericId(chatId);
         await this.bot.api.unpinAllChatMessages(numId);
     }
+    async updateStatus(chatId, text) {
+        const existing = this.statusHandles.get(chatId);
+        if (existing) {
+            try {
+                await this.editMessage(chatId, existing, text);
+                return;
+            }
+            catch (err) {
+                if (!(err instanceof Error && err.message.includes("message is not modified"))) {
+                    // Edit failed for a real reason — fall through to create new
+                    log.warn("[channel] failed to edit status message, will recreate: %s", err instanceof Error ? err.message : String(err));
+                    this.statusHandles.delete(chatId);
+                }
+                else {
+                    return; // text unchanged, nothing to do
+                }
+            }
+        }
+        // No existing handle, or edit failed — create new pinned message
+        try {
+            await this.unpinAllMessages(chatId);
+        }
+        catch { /* not admin */ }
+        const handles = await this.sendMessage(chatId, text);
+        const handle = handles[0];
+        this.statusHandles.set(chatId, handle);
+        try {
+            await this.pinMessage(chatId, handle);
+        }
+        catch (err) {
+            log.warn("[channel] failed to pin status message (bot may not be admin): %s", err instanceof Error ? err.message : String(err));
+        }
+    }
     async setTyping(chatId, isTyping) {
         if (isTyping) {
             if (this.typingIntervals.has(chatId))
@@ -204,10 +270,107 @@ export class TelegramChannel extends EventEmitter {
             }
         }
     }
+    /** 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}`))
+            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 }),
+            },
+        };
+    }
+    /** Shared handler for photo/document messages: download, emit attachment or fallback. */
+    async handleFileMessage(ctx, fileId, mimeType, filename, caption) {
+        const sender = this.extractSender(ctx);
+        if (!sender)
+            return;
+        try {
+            const buffer = await this.downloadFile(fileId);
+            this.emit("message", {
+                ...sender,
+                text: caption ?? "",
+                attachments: [{ buffer, mimeType, filename }],
+            });
+        }
+        catch (err) {
+            log.warn({ err }, "[channel] failed to download file %s", filename ?? fileId);
+            this.emit("message", {
+                ...sender,
+                text: caption
+                    ? `${caption}\n[File download failed: ${filename ?? mimeType}]`
+                    : `[File download failed: ${filename ?? mimeType}]`,
+            });
+        }
+    }
+    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 });
+        }
+    }
+    /** Download a Telegram file by file_id, returning the raw buffer. */
+    async downloadFile(fileId) {
+        const file = await this.bot.api.getFile(fileId);
+        if (!file.file_path)
+            throw new Error("Telegram returned no file_path");
+        const url = `https://api.telegram.org/file/bot${this.botToken}/${file.file_path}`;
+        const resp = await fetch(url);
+        if (!resp.ok)
+            throw new Error(`File download failed: ${resp.status}`);
+        return Buffer.from(await resp.arrayBuffer());
+    }
     numericId(chatId) {
         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,11 +1,21 @@
 import type { PermissionMode } from "./types.js";
-export interface Config {
+export interface TelegramConfig {
+    type: "telegram";
+    botToken: string;
+}
+export interface SlackConfig {
+    type: "slack";
     botToken: string;
+    appToken: string;
+}
+export type ChannelConfig = TelegramConfig | SlackConfig;
+export interface Config {
+    channel: ChannelConfig;
     allowedUserIds: Set<string>;
     permissionMode: PermissionMode;
-    dataDir: string;
     defaultPromptPath: string;
-    workspacesPath: string;
+    workspaceStorePath: string;
+    filesPath: string;
     logPath: string;
 }
 export declare function loadConfig(): Config;

package/dist/config.js

@@ -4,7 +4,21 @@ import path from "node:path";
 export function loadConfig() {
     const dataDir = process.env.CLEARCLAW_HOME ?? path.join(os.homedir(), ".clearclaw");
     fs.mkdirSync(dataDir, { recursive: true });
-    const botToken = requireEnv("TELEGRAM_BOT_TOKEN");
+    fs.mkdirSync(path.join(dataDir, "files"), { recursive: true });
+    // Channel config: Slack takes priority if both SLACK_BOT_TOKEN and SLACK_APP_TOKEN are set
+    const slackBotToken = process.env.SLACK_BOT_TOKEN;
+    const slackAppToken = process.env.SLACK_APP_TOKEN;
+    const telegramBotToken = process.env.TELEGRAM_BOT_TOKEN;
+    let channel;
+    if (slackBotToken && slackAppToken) {
+        channel = { type: "slack", botToken: slackBotToken, appToken: slackAppToken };
+    }
+    else if (telegramBotToken) {
+        channel = { type: "telegram", botToken: telegramBotToken };
+    }
+    else {
+        throw new Error("Missing channel config: set TELEGRAM_BOT_TOKEN or both SLACK_BOT_TOKEN + SLACK_APP_TOKEN");
+    }
     const rawIds = process.env.ALLOWED_USER_IDS ?? process.env.ALLOWED_USER_ID;
     if (!rawIds)
         throw new Error("Missing required env var: ALLOWED_USER_IDS");
@@ -21,12 +35,12 @@ export function loadConfig() {
         throw new Error(`PERMISSION_MODE must be one of: ${valid.join(", ")}`);
     }
     return {
-        botToken,
+        channel,
         allowedUserIds,
         permissionMode,
-        dataDir,
         defaultPromptPath: path.join(dataDir, "workspace", "CLAUDE.md"),
-        workspacesPath: path.join(dataDir, "workspaces.json"),
+        workspaceStorePath: path.join(dataDir, "workspaces.json"),
+        filesPath: path.join(dataDir, "files"),
         logPath: path.join(dataDir, "clearclaw.log"),
     };
 }

package/dist/engine/claude-code.d.ts

@@ -1,5 +1,6 @@
-import type { Engine, EngineEvent, RunTurnOpts } from "../types.js";
+import type { Engine, EngineEvent, RunTurnOpts, SessionInfo } from "../types.js";
 export declare class ClaudeCodeEngine implements Engine {
     name: string;
+    listSessions(cwd: string): Promise<SessionInfo[]>;
     runTurn(opts: RunTurnOpts): AsyncIterable<EngineEvent>;
 }

package/dist/engine/claude-code.js

@@ -1,10 +1,21 @@
-import { query, } from "@anthropic-ai/claude-agent-sdk";
+import { query, listSessions, } from "@anthropic-ai/claude-agent-sdk";
 import log from "../logger.js";
 import { formatToolDescription } from "../format.js";
 export class ClaudeCodeEngine {
     name = "claude-code";
+    async listSessions(cwd) {
+        const sessions = await listSessions({ dir: cwd, limit: 10 });
+        return sessions
+            .sort((a, b) => b.lastModified - a.lastModified)
+            .map((s) => ({
+            sessionId: s.sessionId,
+            summary: s.summary,
+            lastModified: s.lastModified,
+            gitBranch: s.gitBranch,
+        }));
+    }
     async *runTurn(opts) {
-        const { sessionId, cwd, prompt, permissionMode, onPermissionRequest, appendSystemPrompt, signal, } = opts;
+        const { sessionId, cwd, prompt: textPrompt, attachments, permissionMode, onPermissionRequest, appendSystemPrompt, mcpServers, signal, } = opts;
         const abortController = new AbortController();
         // Wire external signal to our abort controller
         if (signal) {
@@ -41,6 +52,10 @@ export class ClaudeCodeEngine {
                 interrupt: !resp.message,
             };
         };
+        // Plain string when no attachments, content blocks when attachments present
+        const prompt = attachments?.length
+            ? buildAttachmentPrompt(textPrompt, attachments)
+            : textPrompt;
         const q = query({
             prompt,
             options: {
@@ -51,6 +66,7 @@ export class ClaudeCodeEngine {
                 canUseTool,
                 abortController,
                 settingSources: ["user", "project", "local"],
+                ...(mcpServers ? { mcpServers } : {}),
                 ...(appendSystemPrompt
                     ? {
                         systemPrompt: {
@@ -105,15 +121,12 @@ export class ClaudeCodeEngine {
                     const content = msg.message.content;
                     if (Array.isArray(content)) {
                         for (const block of content) {
-                            const b = block;
-                            if (b.type === "tool_result" &&
-                                typeof b.tool_use_id === "string") {
-                                const toolName = toolUseIdToName.get(b.tool_use_id) ?? "unknown";
-                                const output = extractToolResultText(b.content);
+                            if (block.type === "tool_result") {
+                                const toolName = toolUseIdToName.get(block.tool_use_id) ?? "unknown";
+                                const output = extractToolResultText(block.content);
                                 if (output) {
                                     yield { type: "tool_result", toolName, output };
                                 }
-                                // Retain for turn-level stats (map is GC'd when generator ends)
                             }
                         }
                     }
@@ -178,6 +191,63 @@ export class ClaudeCodeEngine {
         }
     }
 }
+/**
+ * Build an AsyncIterable<SDKUserMessage> that yields a single user message
+ * with content blocks for attachments + text.
+ */
+function buildAttachmentPrompt(text, attachments) {
+    const contentBlocks = attachments.map(encodeAttachment);
+    // Text prompt always comes last
+    if (text) {
+        contentBlocks.push({ type: "text", text });
+    }
+    const message = { role: "user", content: contentBlocks };
+    // SDKUserMessage requires these fields for type satisfaction, but they're
+    // not semantically meaningful here — we're injecting a top-level prompt,
+    // not replaying a conversation. Session management is handled by the
+    // `resume` option passed to query().
+    const msg = {
+        type: "user",
+        message,
+        parent_tool_use_id: null,
+        session_id: "",
+    };
+    return (async function* () {
+        yield msg;
+    })();
+}
+const SUPPORTED_IMAGE_TYPES = new Set([
+    "image/jpeg", "image/png", "image/gif", "image/webp",
+]);
+/** Encode an attachment as an SDK content block using its in-memory buffer. */
+function encodeAttachment(att) {
+    const data = att.buffer.toString("base64");
+    if (SUPPORTED_IMAGE_TYPES.has(att.mimeType)) {
+        return {
+            type: "image",
+            source: {
+                type: "base64",
+                media_type: att.mimeType,
+                data,
+            },
+        };
+    }
+    if (att.mimeType === "application/pdf") {
+        return {
+            type: "document",
+            source: { type: "base64", media_type: "application/pdf", data },
+        };
+    }
+    if (att.mimeType.startsWith("text/")) {
+        const content = att.buffer.toString("utf-8");
+        const header = att.filename ? `--- ${att.filename} ---\n` : "";
+        return { type: "text", text: `${header}${content}` };
+    }
+    // Unsupported (includes non-standard image types like svg, bmp, tiff)
+    const name = att.filename ?? att.mimeType;
+    log.warn("[engine] unsupported attachment type: %s", att.mimeType);
+    return { type: "text", text: `[Unsupported file: ${name}]` };
+}
 /** Pull plain text out of a tool_result content block. */
 function extractToolResultText(content) {
     if (typeof content === "string")

package/dist/files.d.ts

@@ -0,0 +1,3 @@
+import type { Attachment } from "./types.js";
+/** Save an attachment to disk for audit logging. Returns the saved file path. */
+export declare function saveFile(att: Attachment, workspace: string, filesPath: string): Promise<string>;

package/dist/files.js

@@ -0,0 +1,24 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import mime from "mime";
+import path from "node:path";
+/** Save an attachment to disk for audit logging. Returns the saved file path. */
+export async function saveFile(att, workspace, filesPath) {
+    const epoch = Math.floor(Date.now() / 1000);
+    const hex = crypto.randomBytes(2).toString("hex");
+    const name = att.filename
+        ? sanitizeFilename(att.filename)
+        : `file${att.mimeType ? `.${mime.getExtension(att.mimeType) ?? "bin"}` : ""}`;
+    const filename = `${workspace}-${epoch}-${hex}-${name}`;
+    const filePath = path.join(filesPath, filename);
+    await fs.writeFile(filePath, att.buffer);
+    return filePath;
+}
+/** Strip path separators and null bytes, collapse whitespace. */
+function sanitizeFilename(name) {
+    return name
+        .replace(/[/\\\0]/g, "_")
+        .replace(/\s+/g, "_")
+        .slice(0, 200);
+}
+//# sourceMappingURL=files.js.map

package/dist/format.d.ts

@@ -18,6 +18,10 @@ export declare function formatToolStatusLine(toolName: string, input: Record<str
  * Edit/Write include the diff/preview; other tools get a one-line description.
  */
 export declare function formatPermissionPrompt(toolName: string, input: Record<string, unknown>, description: string): string;
+/**
+ * Relative time string: "just now", "5m ago", "2h ago", "3d ago".
+ */
+export declare function timeAgo(epochMs: number): string;
 /**
  * Human-readable one-liner for a tool invocation (used in engine's canUseTool).
  */

package/dist/format.js

@@ -41,22 +41,19 @@ export function formatPermissionPrompt(toolName, input, description) {
         const lines = patch.split("\n");
         const start = lines.findIndex((l) => l.startsWith("---"));
         const diffLines = start >= 0 ? lines.slice(start) : lines;
-        const body = escapeMarkdownV2(truncateLines(diffLines, MAX_LINES), true);
-        const header = escapeMarkdownV2(`🔐 Allow Edit? ${edit.file_path}`);
-        return `${header}\n\`\`\`diff\n${body}\n\`\`\``;
+        const body = truncateLines(diffLines, MAX_LINES);
+        return `🔐 Allow Edit? ${edit.file_path}\n\`\`\`diff\n${body}\n\`\`\``;
     }
     if (toolName === "Write") {
         const write = input;
         const lines = write.content.split("\n");
-        const body = escapeMarkdownV2(truncateLines(lines, MAX_LINES), true);
-        const header = escapeMarkdownV2(`🔐 Allow Write? ${write.file_path} (${lines.length} lines)`);
-        return `${header}\n\`\`\`\n${body}\n\`\`\``;
+        const body = truncateLines(lines, MAX_LINES);
+        return `🔐 Allow Write? ${write.file_path} (${lines.length} lines)\n\`\`\`\n${body}\n\`\`\``;
     }
     // Non-Edit/Write tools: emoji header + detail in code block
     const detail = formatToolDetail(toolName, input);
-    const header = escapeMarkdownV2(`🔐 Allow ${toolName}?`);
-    const body = escapeMarkdownV2(truncateLines(detail.split("\n"), MAX_LINES), true);
-    return `${header}\n\`\`\`\n${body}\n\`\`\``;
+    const body = truncateLines(detail.split("\n"), MAX_LINES);
+    return `🔐 Allow ${toolName}?\n\`\`\`\n${body}\n\`\`\``;
 }
 function formatToolStatus(toolName, input) {
     switch (toolName) {
@@ -104,6 +101,22 @@ function formatToolDetail(toolName, input) {
             return JSON.stringify(input, null, 2);
     }
 }
+/**
+ * Relative time string: "just now", "5m ago", "2h ago", "3d ago".
+ */
+export function timeAgo(epochMs) {
+    const seconds = Math.floor((Date.now() - epochMs) / 1000);
+    if (seconds < 60)
+        return "just now";
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
 function truncateLines(lines, max) {
     if (lines.length <= max) {
         return lines.join("\n");
@@ -112,15 +125,6 @@ function truncateLines(lines, max) {
     const remaining = lines.length - max;
     return `${shown}\n... (${remaining} more lines)`;
 }
-/**
- * Escape for Telegram MarkdownV2.
- * Outside code blocks: all special chars. Inside: only backtick and backslash
- * (other chars are literal inside pre blocks, escaping them adds visible backslashes).
- */
-function escapeMarkdownV2(text, codeBlock = false) {
-    const pattern = codeBlock ? /[`\\]/g : /[_*\[\]()~`>#+\-=|{}.!\\]/g;
-    return text.replace(pattern, "\\$&");
-}
 /**
  * Human-readable one-liner for a tool invocation (used in engine's canUseTool).
  */

package/dist/index.js

@@ -4,6 +4,7 @@ import log, { initLogger } from "./logger.js";
 import { WorkspaceStore } from "./workspace-store.js";
 import { ClaudeCodeEngine } from "./engine/claude-code.js";
 import { TelegramChannel } from "./channel/telegram.js";
+import { SlackChannel } from "./channel/slack.js";
 import { Orchestrator } from "./orchestrator.js";
 // The Claude Agent SDK has a bug: handleControlRequest() writes to the
 // subprocess stdin without a .catch(), so aborting during a permission
@@ -23,8 +24,14 @@ process.on("unhandledRejection", (reason) => {
 async function main() {
     const config = loadConfig();
     initLogger(config.logPath);
-    const workspaceStore = new WorkspaceStore(config.workspacesPath);
-    const channel = new TelegramChannel(config.botToken, config.allowedUserIds);
+    const workspaceStore = new WorkspaceStore(config.workspaceStorePath);
+    let channel;
+    if (config.channel.type === "slack") {
+        channel = new SlackChannel(config.channel.botToken, config.channel.appToken, config.allowedUserIds);
+    }
+    else {
+        channel = new TelegramChannel(config.channel.botToken, config.allowedUserIds);
+    }
     const engine = new ClaudeCodeEngine();
     const orchestrator = new Orchestrator({
         channel,
@@ -32,6 +39,7 @@ async function main() {
         workspaceStore,
         permissionMode: config.permissionMode,
         defaultPromptPath: config.defaultPromptPath,
+        filesPath: config.filesPath,
     });
     await orchestrator.start();
 }

package/dist/logger.js

@@ -16,7 +16,7 @@ export function initLogger(logPath) {
                         file: logPath,
                         frequency: "daily",
                         size: "10m",
-                        limit: { count: 5 },
+                        limit: { count: 5, removeOtherLogFiles: true },
                     },
                     level: process.env.LOG_LEVEL ?? "info",
                 },