clearclaw 0.1.0

package/dist/channel/telegram.d.ts

@@ -0,0 +1,17 @@
+import { EventEmitter } from "node:events";
+import type { Channel, Button, ButtonResponse, SendMessageOpts } from "../types.js";
+export declare class TelegramChannel extends EventEmitter implements Channel {
+    name: string;
+    private bot;
+    private allowedUserId;
+    private typingIntervals;
+    private pendingCallbacks;
+    constructor(botToken: string, allowedUserId: number);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    ownsId(chatId: string): boolean;
+    sendMessage(chatId: string, text: string, opts?: SendMessageOpts): Promise<void>;
+    sendInteractive(chatId: string, text: string, buttons: Button[]): Promise<ButtonResponse>;
+    setTyping(chatId: string, isTyping: boolean): Promise<void>;
+    private numericId;
+}

package/dist/channel/telegram.js

@@ -0,0 +1,162 @@
+import { EventEmitter } from "node:events";
+import { Bot, InlineKeyboard } from "grammy";
+import log from "../logger.js";
+export class TelegramChannel extends EventEmitter {
+    name = "telegram";
+    bot;
+    allowedUserId;
+    typingIntervals = new Map();
+    // Pending interactive responses: callbackId → resolve function
+    pendingCallbacks = new Map();
+    constructor(botToken, allowedUserId) {
+        super();
+        this.allowedUserId = allowedUserId;
+        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.allowedUserId)
+                return;
+            const chatId = `tg:${ctx.chat.id}`;
+            this.emit("message", { chatId, text: ctx.message.text });
+        });
+        // Handle inline keyboard button presses
+        this.bot.on("callback_query:data", async (ctx) => {
+            const data = ctx.callbackQuery.data;
+            const resolve = this.pendingCallbacks.get(data);
+            if (resolve) {
+                this.pendingCallbacks.delete(data);
+                resolve(data);
+            }
+            await ctx.answerCallbackQuery();
+        });
+        this.bot.catch((err) => {
+            log.error("[channel] Telegram bot error: %s", err.message);
+        });
+        await new Promise((resolve) => {
+            this.bot.start({
+                onStart: (botInfo) => {
+                    log.info(`[channel] Telegram bot: @${botInfo.username}`);
+                    resolve();
+                },
+            });
+        });
+    }
+    async disconnect() {
+        for (const interval of this.typingIntervals.values()) {
+            clearInterval(interval);
+        }
+        this.typingIntervals.clear();
+        await this.bot.stop();
+    }
+    ownsId(chatId) {
+        return chatId.startsWith("tg:");
+    }
+    async sendMessage(chatId, text, opts) {
+        const numId = this.numericId(chatId);
+        const chunks = splitMessage(text);
+        for (const chunk of chunks) {
+            try {
+                await this.bot.api.sendMessage(numId, chunk, {
+                    parse_mode: opts?.parseMode,
+                });
+            }
+            catch (err) {
+                if (opts?.parseMode) {
+                    log.warn("[channel] sendMessage failed with %s, retrying as plain text", opts.parseMode);
+                    await this.bot.api.sendMessage(numId, chunk);
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+    }
+    async sendInteractive(chatId, text, buttons) {
+        const numId = this.numericId(chatId);
+        const callbackId = crypto.randomUUID().slice(0, 8);
+        // Pre-compute callback data keys
+        const cbEntries = buttons.map((btn) => ({
+            btn,
+            cbData: `${callbackId}:${btn.value}`,
+        }));
+        // Build inline keyboard
+        const keyboard = new InlineKeyboard();
+        for (const { btn, cbData } of cbEntries) {
+            keyboard.text(btn.label, cbData);
+        }
+        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)
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                cleanupAll();
+                resolve({ value: "" });
+            }, 30 * 60 * 1000);
+            for (const { btn, cbData } of cbEntries) {
+                this.pendingCallbacks.set(cbData, () => {
+                    clearTimeout(timeout);
+                    cleanupAll();
+                    resolve({ value: btn.value });
+                });
+            }
+        });
+    }
+    async setTyping(chatId, isTyping) {
+        if (isTyping) {
+            if (this.typingIntervals.has(chatId))
+                return;
+            const numId = this.numericId(chatId);
+            // Send immediately, then repeat every 4s
+            await this.bot.api
+                .sendChatAction(numId, "typing")
+                .catch(() => { });
+            const interval = setInterval(() => {
+                this.bot.api.sendChatAction(numId, "typing").catch(() => { });
+            }, 4000);
+            this.typingIntervals.set(chatId, interval);
+        }
+        else {
+            const interval = this.typingIntervals.get(chatId);
+            if (interval) {
+                clearInterval(interval);
+                this.typingIntervals.delete(chatId);
+            }
+        }
+    }
+    numericId(chatId) {
+        return Number(chatId.replace(/^tg:/, ""));
+    }
+}
+const MAX_MSG_LEN = 4096;
+/** Split text into ≤4096-char chunks, preferring newline boundaries. */
+function splitMessage(text) {
+    if (text.length <= MAX_MSG_LEN)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > MAX_MSG_LEN) {
+        // Find last newline within the limit
+        const newlineAt = remaining.lastIndexOf("\n", MAX_MSG_LEN);
+        if (newlineAt > 0) {
+            chunks.push(remaining.slice(0, newlineAt));
+            remaining = remaining.slice(newlineAt + 1); // skip the newline
+        }
+        else {
+            // No newline found — hard split, no char skipped
+            chunks.push(remaining.slice(0, MAX_MSG_LEN));
+            remaining = remaining.slice(MAX_MSG_LEN);
+        }
+    }
+    if (remaining)
+        chunks.push(remaining);
+    return chunks;
+}
+//# sourceMappingURL=telegram.js.map

package/dist/config.d.ts

@@ -0,0 +1,10 @@
+import type { PermissionMode } from "./types.js";
+export interface Config {
+    botToken: string;
+    allowedUserId: number;
+    permissionMode: PermissionMode;
+    dataDir: string;
+    workspacesPath: string;
+    logPath: string;
+}
+export declare function loadConfig(): Config;

package/dist/config.js

@@ -0,0 +1,38 @@
+import fs from "node:fs";
+import os from "node:os";
+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");
+    const allowedUserId = Number(requireEnv("ALLOWED_USER_ID"));
+    if (Number.isNaN(allowedUserId)) {
+        throw new Error("ALLOWED_USER_ID must be a number");
+    }
+    const permissionMode = (process.env.PERMISSION_MODE ?? "default");
+    const valid = [
+        "default",
+        "acceptEdits",
+        "bypassPermissions",
+        "plan",
+        "dontAsk",
+    ];
+    if (!valid.includes(permissionMode)) {
+        throw new Error(`PERMISSION_MODE must be one of: ${valid.join(", ")}`);
+    }
+    return {
+        botToken,
+        allowedUserId,
+        permissionMode,
+        dataDir,
+        workspacesPath: path.join(dataDir, "workspaces.json"),
+        logPath: path.join(dataDir, "clearclaw.log"),
+    };
+}
+function requireEnv(name) {
+    const val = process.env[name];
+    if (!val)
+        throw new Error(`Missing required env var: ${name}`);
+    return val;
+}
+//# sourceMappingURL=config.js.map

package/dist/db.d.ts

@@ -0,0 +1,6 @@
+import type { Workspace } from "./types.js";
+export declare function initDb(): void;
+export declare function getWorkspaceByChat(chatId: string): Workspace | undefined;
+export declare function upsertWorkspace(ws: Workspace): void;
+export declare function updateSessionId(name: string, sessionId: string): void;
+export declare function clearSession(name: string): void;

package/dist/db.js

@@ -0,0 +1,42 @@
+import Database from "better-sqlite3";
+import { dbPath } from "./config.js";
+let db;
+// Cached prepared statements (initialized in initDb)
+let stmtGetByChat;
+let stmtUpsert;
+let stmtUpdateSession;
+let stmtClearSession;
+export function initDb() {
+    db = new Database(dbPath());
+    db.pragma("journal_mode = WAL");
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS workspaces (
+      name TEXT PRIMARY KEY,
+      cwd TEXT NOT NULL,
+      chat_id TEXT UNIQUE,
+      current_session_id TEXT
+    );
+  `);
+    stmtGetByChat = db.prepare("SELECT name, cwd, chat_id, current_session_id FROM workspaces WHERE chat_id = ?");
+    stmtUpsert = db.prepare(`INSERT INTO workspaces (name, cwd, chat_id, current_session_id)
+     VALUES (@name, @cwd, @chat_id, @current_session_id)
+     ON CONFLICT(name) DO UPDATE SET
+       cwd = excluded.cwd,
+       chat_id = excluded.chat_id,
+       current_session_id = excluded.current_session_id`);
+    stmtUpdateSession = db.prepare("UPDATE workspaces SET current_session_id = ? WHERE name = ?");
+    stmtClearSession = db.prepare("UPDATE workspaces SET current_session_id = NULL WHERE name = ?");
+}
+export function getWorkspaceByChat(chatId) {
+    return stmtGetByChat.get(chatId);
+}
+export function upsertWorkspace(ws) {
+    stmtUpsert.run(ws);
+}
+export function updateSessionId(name, sessionId) {
+    stmtUpdateSession.run(sessionId, name);
+}
+export function clearSession(name) {
+    stmtClearSession.run(name);
+}
+//# sourceMappingURL=db.js.map

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

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

package/dist/engine/claude-code.js

@@ -0,0 +1,137 @@
+import { query, } from "@anthropic-ai/claude-agent-sdk";
+import log from "../logger.js";
+import { formatToolDescription } from "../format.js";
+export class ClaudeCodeEngine {
+    name = "claude-code";
+    async *runTurn(opts) {
+        const { sessionId, cwd, prompt, permissionMode, onPermissionRequest, signal, } = opts;
+        const abortController = new AbortController();
+        // Wire external signal to our abort controller
+        if (signal) {
+            signal.addEventListener("abort", () => abortController.abort(), {
+                once: true,
+            });
+        }
+        const sessionOpts = sessionId
+            ? { resume: sessionId }
+            : {};
+        const canUseTool = async (toolName, input, options) => {
+            const description = formatToolDescription(toolName, input);
+            const resp = await onPermissionRequest({
+                toolName,
+                input,
+                description,
+                reason: options.decisionReason,
+            });
+            if (resp.decision === "allow") {
+                return { behavior: "allow", updatedInput: input };
+            }
+            return { behavior: "deny", message: "User denied" };
+        };
+        const q = query({
+            prompt,
+            options: {
+                ...sessionOpts,
+                cwd,
+                permissionMode,
+                allowDangerouslySkipPermissions: permissionMode === "bypassPermissions" ? true : undefined,
+                canUseTool,
+                abortController,
+                settingSources: ["user", "project", "local"],
+            },
+        });
+        let resultSessionId;
+        const toolUseIdToName = new Map();
+        try {
+            for await (const msg of q) {
+                if (msg.type !== "assistant") {
+                    const sub = msg.type === "result" ? ` (${msg.subtype})` : "";
+                    log.info(`[sdk] ${msg.type}${sub}`);
+                }
+                // Extract text and tool_use from assistant messages
+                if (msg.type === "assistant") {
+                    const { content } = msg.message;
+                    for (const block of content) {
+                        if (block.type === "text" && block.text) {
+                            yield { type: "text", text: block.text };
+                        }
+                        if (block.type === "tool_use") {
+                            toolUseIdToName.set(block.id, block.name);
+                            yield {
+                                type: "tool_use",
+                                toolName: block.name,
+                                input: block.input,
+                            };
+                        }
+                    }
+                }
+                // Extract tool results from user messages
+                if (msg.type === "user") {
+                    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 (output) {
+                                    yield { type: "tool_result", toolName, output };
+                                }
+                                toolUseIdToName.delete(b.tool_use_id);
+                            }
+                        }
+                    }
+                }
+                // Relay rate limit events
+                if (msg.type === "rate_limit_event") {
+                    const { rate_limit_info } = msg;
+                    if (rate_limit_info.status !== "allowed") {
+                        yield {
+                            type: "rate_limit",
+                            status: rate_limit_info.status,
+                            resetsAt: rate_limit_info.resetsAt,
+                        };
+                    }
+                }
+                // Relay local command output (e.g. /compact, /cost, /model)
+                if (msg.type === "system" && msg.subtype === "local_command_output") {
+                    const cmdOut = msg;
+                    if (cmdOut.content) {
+                        yield { type: "text", text: cmdOut.content };
+                    }
+                }
+                // Capture result
+                if (msg.type === "result") {
+                    const result = msg;
+                    resultSessionId = result.session_id;
+                    if (result.subtype !== "success" && result.errors.length) {
+                        yield { type: "error", message: result.errors.join("\n") };
+                    }
+                }
+            }
+        }
+        catch (err) {
+            yield {
+                type: "error",
+                message: err instanceof Error ? err.message : String(err),
+            };
+        }
+        if (resultSessionId) {
+            yield { type: "done", sessionId: resultSessionId };
+        }
+    }
+}
+/** Pull plain text out of a tool_result content block. */
+function extractToolResultText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .filter((b) => b.type === "text" && typeof b.text === "string")
+            .map((b) => b.text)
+            .join("\n");
+    }
+    return "";
+}
+//# sourceMappingURL=claude-code.js.map

package/dist/format.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Diff formatting utilities for tool_use display in Telegram.
+ *
+ * Uses the `diff` library for proper unified diffs with context lines.
+ */
+/**
+ * Format a tool_use event for display. Returns a MarkdownV2 string.
+ * Edit/Write get rich formatting; all others get a one-line status.
+ */
+export declare function formatToolUse(toolName: string, input: Record<string, unknown>): string;
+/**
+ * Format a tool_result event for display. Returns a MarkdownV2 code block
+ * with input + output, or null if suppressed/empty.
+ */
+export declare function formatToolResult(toolName: string, output: string): string | null;
+/**
+ * Human-readable one-liner for a tool invocation (used in permission prompts).
+ */
+export declare function formatToolDescription(toolName: string, input: Record<string, unknown>): string;

package/dist/format.js

@@ -0,0 +1,106 @@
+/**
+ * Diff formatting utilities for tool_use display in Telegram.
+ *
+ * Uses the `diff` library for proper unified diffs with context lines.
+ */
+import { createTwoFilesPatch } from "diff";
+const MAX_LINES = 200;
+/**
+ * Format a tool_use event for display. Returns a MarkdownV2 string.
+ * Edit/Write get rich formatting; all others get a one-line status.
+ */
+export function formatToolUse(toolName, input) {
+    if (toolName === "Edit") {
+        return formatEditDiff(input);
+    }
+    if (toolName === "Write") {
+        return formatWritePreview(input);
+    }
+    return escapeMarkdownV2(`🔧 ${formatToolStatus(toolName, input)}`);
+}
+function formatToolStatus(toolName, input) {
+    switch (toolName) {
+        case "Bash":
+            return `Bash: ${input.command ?? "(unknown)"}`;
+        case "Read":
+            return `Read: ${input.file_path ?? "(unknown)"}`;
+        case "Glob":
+            return `Glob: ${input.pattern ?? "(unknown)"}`;
+        case "Grep":
+            return `Grep: ${input.pattern ?? "(unknown)"}`;
+        case "WebFetch":
+            return `WebFetch: ${input.url ?? "(unknown)"}`;
+        case "WebSearch":
+            return `WebSearch: ${input.query ?? "(unknown)"}`;
+        case "Agent":
+            return `Agent: ${input.description ?? "(unknown)"}`;
+        default:
+            return toolName;
+    }
+}
+function formatEditDiff(input) {
+    const patch = createTwoFilesPatch(`a/${input.file_path}`, `b/${input.file_path}`, input.old_string, input.new_string, "", "", { context: 3 });
+    // Strip the "Index:" / "===" preamble, keep --- / +++ / @@ lines onward.
+    const lines = patch.split("\n");
+    const start = lines.findIndex((l) => l.startsWith("---"));
+    const diffLines = start >= 0 ? lines.slice(start) : lines;
+    const body = truncateLines(diffLines, MAX_LINES);
+    const header = escapeMarkdownV2(`\u270f\ufe0f Edit: ${input.file_path}`);
+    return `${header}\n\`\`\`diff\n${body}\n\`\`\``;
+}
+function formatWritePreview(input) {
+    const lines = input.content.split("\n");
+    const totalLines = lines.length;
+    const body = truncateLines(lines, MAX_LINES);
+    const header = escapeMarkdownV2(`\ud83d\udcc4 Write: ${input.file_path} (${totalLines} lines)`);
+    return `${header}\n\`\`\`\n${body}\n\`\`\``;
+}
+function truncateLines(lines, max) {
+    if (lines.length <= max) {
+        return lines.join("\n");
+    }
+    const shown = lines.slice(0, max).join("\n");
+    const remaining = lines.length - max;
+    return `${shown}\n... (${remaining} more lines)`;
+}
+// Tools whose output is noisy or redundant (tool_use already shows input).
+// New/unknown tools show by default.
+const SUPPRESSED_RESULTS = new Set([
+    "Read", "Edit", "Write", "Glob", "Agent",
+    "TodoWrite", "NotebookEdit", "EnterPlanMode", "ExitPlanMode",
+]);
+/**
+ * Format a tool_result event for display. Returns a MarkdownV2 code block
+ * with input + output, or null if suppressed/empty.
+ */
+export function formatToolResult(toolName, output) {
+    if (SUPPRESSED_RESULTS.has(toolName))
+        return null;
+    if (!output.trim())
+        return null;
+    const body = truncateLines(output.split("\n"), MAX_LINES);
+    return `\`\`\`\n${body}\n\`\`\``;
+}
+/**
+ * Escape special characters for MarkdownV2 (outside code blocks).
+ * Inside ``` blocks, no escaping is needed.
+ */
+function escapeMarkdownV2(text) {
+    return text.replace(/([_*\[\]()~`>#+\-=|{}.!\\])/g, "\\$1");
+}
+/**
+ * Human-readable one-liner for a tool invocation (used in permission prompts).
+ */
+export function formatToolDescription(toolName, input) {
+    switch (toolName) {
+        case "Bash":
+            return `Bash: ${input.command ?? "(unknown command)"}`;
+        case "Edit":
+        case "Write":
+        case "Read":
+            return `${toolName}: ${input.file_path ?? "(unknown file)"}`;
+        default:
+            return `Allow ${toolName}?`;
+    }
+}
+//# sourceMappingURL=format.js.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { loadConfig } from "./config.js";
+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 { Orchestrator } from "./orchestrator.js";
+async function main() {
+    const config = loadConfig();
+    initLogger(config.logPath);
+    const workspaceStore = new WorkspaceStore(config.workspacesPath);
+    const channel = new TelegramChannel(config.botToken, config.allowedUserId);
+    const engine = new ClaudeCodeEngine();
+    const orchestrator = new Orchestrator({
+        channel,
+        engine,
+        workspaceStore,
+        permissionMode: config.permissionMode,
+    });
+    await orchestrator.start();
+}
+main().catch((err) => {
+    log.fatal({ err }, "Fatal");
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/logger.d.ts

@@ -0,0 +1,4 @@
+import pino from "pino";
+declare let log: pino.Logger<never, boolean>;
+export declare function initLogger(logPath: string): void;
+export { log as default };

package/dist/logger.js

@@ -0,0 +1,28 @@
+import pino from "pino";
+let log = pino({ level: "silent" });
+export function initLogger(logPath) {
+    log = pino({
+        level: process.env.LOG_LEVEL ?? "info",
+        transport: {
+            targets: [
+                {
+                    target: "pino-pretty",
+                    options: { destination: 1 },
+                    level: process.env.LOG_LEVEL ?? "info",
+                },
+                {
+                    target: "pino-roll",
+                    options: {
+                        file: logPath,
+                        frequency: "daily",
+                        size: "10m",
+                        limit: { count: 5 },
+                    },
+                    level: process.env.LOG_LEVEL ?? "info",
+                },
+            ],
+        },
+    });
+}
+export { log as default };
+//# sourceMappingURL=logger.js.map

package/dist/orchestrator.d.ts

@@ -0,0 +1,20 @@
+import type { WorkspaceStore } from "./workspace-store.js";
+import type { Channel, Engine, PermissionMode } from "./types.js";
+export interface OrchestratorOpts {
+    channel: Channel;
+    engine: Engine;
+    workspaceStore: WorkspaceStore;
+    permissionMode: PermissionMode;
+}
+export declare class Orchestrator {
+    private channel;
+    private engine;
+    private workspaceStore;
+    private permissionMode;
+    private busyChats;
+    constructor(opts: OrchestratorOpts);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleMessage;
+    private routeEngineEvent;
+}

package/dist/orchestrator.js

@@ -0,0 +1,135 @@
+import log from "./logger.js";
+import { formatToolUse, formatToolResult } from "./format.js";
+export class Orchestrator {
+    channel;
+    engine;
+    workspaceStore;
+    permissionMode;
+    busyChats = new Set();
+    constructor(opts) {
+        this.channel = opts.channel;
+        this.engine = opts.engine;
+        this.workspaceStore = opts.workspaceStore;
+        this.permissionMode = opts.permissionMode;
+    }
+    async start() {
+        this.channel.on("message", (msg) => {
+            this.handleMessage(msg).catch((err) => {
+                log.error({ err }, "[orchestrator] unhandled message error");
+            });
+        });
+        await this.channel.connect();
+        log.info("ClearClaw ready.");
+        const shutdown = async () => {
+            await this.stop();
+            process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+    }
+    async stop() {
+        await this.channel.disconnect();
+    }
+    async handleMessage(msg) {
+        try {
+            log.info(`[msg] ${msg.text.slice(0, 80)}`);
+            // /new — reset session
+            if (msg.text === "/new") {
+                const ws = this.workspaceStore.byChat(msg.chatId);
+                if (!ws) {
+                    await this.channel.sendMessage(msg.chatId, "No workspace linked to this group.");
+                    return;
+                }
+                this.workspaceStore.clearSession(ws.name);
+                log.info("[cmd] session cleared for workspace %s", ws.name);
+                await this.channel.sendMessage(msg.chatId, "Session cleared.");
+                return;
+            }
+            // Reject during active turn (per-workspace)
+            if (this.busyChats.has(msg.chatId)) {
+                log.info("[msg] rejected (busy)");
+                await this.channel.sendMessage(msg.chatId, "Still working on the previous message...");
+                return;
+            }
+            this.busyChats.add(msg.chatId);
+            const ws = this.workspaceStore.byChat(msg.chatId);
+            if (!ws) {
+                log.info("[msg] no workspace for chat %s", msg.chatId);
+                this.busyChats.delete(msg.chatId);
+                await this.channel.sendMessage(msg.chatId, "No workspace linked to this group.");
+                return;
+            }
+            log.info(`[turn] start session=${ws.current_session_id ?? "new"} cwd=${ws.cwd}`);
+            await this.channel.setTyping(msg.chatId, true);
+            try {
+                for await (const event of this.engine.runTurn({
+                    sessionId: ws.current_session_id,
+                    cwd: ws.cwd,
+                    prompt: msg.text,
+                    permissionMode: this.permissionMode,
+                    onPermissionRequest: async (req) => {
+                        log.info(`[perm] ${req.toolName}`);
+                        const resp = await this.channel.sendInteractive(msg.chatId, `Allow ${req.toolName}?`, [
+                            { label: "Allow", value: "allow" },
+                            { label: "Deny", value: "deny" },
+                        ]);
+                        log.info(`[perm] ${req.toolName} → ${resp.value || "timeout"}`);
+                        return {
+                            decision: resp.value === "allow" ? "allow" : "deny",
+                        };
+                    },
+                })) {
+                    await this.routeEngineEvent(msg.chatId, event, ws.name);
+                }
+            }
+            finally {
+                this.busyChats.delete(msg.chatId);
+                await this.channel.setTyping(msg.chatId, false);
+            }
+        }
+        catch (err) {
+            log.error({ err }, "[fatal]");
+            await this.channel.sendMessage(msg.chatId, `Internal error: ${err instanceof Error ? err.message : String(err)}`).catch(() => { });
+        }
+    }
+    async routeEngineEvent(chatId, event, workspaceName) {
+        switch (event.type) {
+            case "text":
+                await this.channel.sendMessage(chatId, event.text);
+                break;
+            case "tool_use": {
+                const formatted = formatToolUse(event.toolName, event.input);
+                await this.channel.sendMessage(chatId, formatted, {
+                    parseMode: "MarkdownV2",
+                });
+                break;
+            }
+            case "tool_result": {
+                const formatted = formatToolResult(event.toolName, event.output);
+                if (formatted) {
+                    await this.channel.sendMessage(chatId, formatted, {
+                        parseMode: "MarkdownV2",
+                    });
+                }
+                break;
+            }
+            case "rate_limit": {
+                const resetMsg = event.resetsAt
+                    ? ` Resets at ${new Date(event.resetsAt).toLocaleTimeString()}.`
+                    : "";
+                log.warn(`[turn] rate limit: ${event.status}${resetMsg}`);
+                await this.channel.sendMessage(chatId, `⚠️ Rate limited (${event.status}).${resetMsg}`);
+                break;
+            }
+            case "done":
+                log.info(`[turn] done session=${event.sessionId}`);
+                this.workspaceStore.setSession(workspaceName, event.sessionId);
+                break;
+            case "error":
+                log.error(`[turn] error: ${event.message}`);
+                await this.channel.sendMessage(chatId, `Error: ${event.message}`);
+                break;
+        }
+    }
+}
+//# sourceMappingURL=orchestrator.js.map

package/dist/types.d.ts

@@ -0,0 +1,80 @@
+import type { PermissionMode } from "@anthropic-ai/claude-agent-sdk";
+export interface ChannelEvents {
+    message: [msg: InboundMessage];
+}
+export interface Channel {
+    name: string;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    ownsId(chatId: string): boolean;
+    sendMessage(chatId: string, text: string, opts?: SendMessageOpts): Promise<void>;
+    sendInteractive(chatId: string, text: string, buttons: Button[]): Promise<ButtonResponse>;
+    setTyping(chatId: string, isTyping: boolean): Promise<void>;
+    on<K extends keyof ChannelEvents>(event: K, listener: (...args: ChannelEvents[K]) => void): this;
+    off<K extends keyof ChannelEvents>(event: K, listener: (...args: ChannelEvents[K]) => void): this;
+    emit<K extends keyof ChannelEvents>(event: K, ...args: ChannelEvents[K]): boolean;
+}
+export interface Button {
+    label: string;
+    value: string;
+}
+export interface ButtonResponse {
+    value: string;
+}
+export interface SendMessageOpts {
+    parseMode?: "MarkdownV2" | "HTML";
+}
+export interface Engine {
+    name: string;
+    runTurn(opts: RunTurnOpts): AsyncIterable<EngineEvent>;
+}
+export interface RunTurnOpts {
+    sessionId: string | null;
+    cwd: string;
+    prompt: string;
+    permissionMode: PermissionMode;
+    onPermissionRequest: (req: PermissionRequest) => Promise<PermissionResponse>;
+    signal?: AbortSignal;
+}
+export interface PermissionRequest {
+    toolName: string;
+    input: Record<string, unknown>;
+    description: string;
+    reason?: string;
+}
+export interface PermissionResponse {
+    decision: "allow" | "deny";
+}
+export type EngineEvent = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_use";
+    toolName: string;
+    input: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    toolName: string;
+    output: string;
+} | {
+    type: "rate_limit";
+    status: string;
+    resetsAt?: number;
+} | {
+    type: "done";
+    sessionId: string;
+} | {
+    type: "error";
+    message: string;
+};
+export interface Workspace {
+    name: string;
+    cwd: string;
+    chat_id: string;
+    current_session_id: string | null;
+}
+export interface InboundMessage {
+    chatId: string;
+    text: string;
+}
+export type { PermissionMode };

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/workspace-store.d.ts

@@ -0,0 +1,11 @@
+import type { Workspace } from "./types.js";
+export declare class WorkspaceStore {
+    private readonly path;
+    constructor(path: string);
+    private read;
+    private write;
+    byChat(chatId: string): Workspace | undefined;
+    upsert(ws: Workspace): void;
+    setSession(name: string, sessionId: string): void;
+    clearSession(name: string): void;
+}

package/dist/workspace-store.js

@@ -0,0 +1,45 @@
+import fs from "node:fs";
+export class WorkspaceStore {
+    path;
+    constructor(path) {
+        this.path = path;
+        if (!fs.existsSync(path)) {
+            fs.writeFileSync(path, "[]\n");
+        }
+    }
+    read() {
+        return JSON.parse(fs.readFileSync(this.path, "utf-8"));
+    }
+    write(workspaces) {
+        fs.writeFileSync(this.path, JSON.stringify(workspaces, null, 2) + "\n");
+    }
+    byChat(chatId) {
+        return this.read().find((ws) => ws.chat_id === chatId);
+    }
+    upsert(ws) {
+        const all = this.read();
+        const idx = all.findIndex((w) => w.name === ws.name);
+        if (idx >= 0)
+            all[idx] = ws;
+        else
+            all.push(ws);
+        this.write(all);
+    }
+    setSession(name, sessionId) {
+        const all = this.read();
+        const ws = all.find((w) => w.name === name);
+        if (ws) {
+            ws.current_session_id = sessionId;
+            this.write(all);
+        }
+    }
+    clearSession(name) {
+        const all = this.read();
+        const ws = all.find((w) => w.name === name);
+        if (ws) {
+            ws.current_session_id = null;
+            this.write(all);
+        }
+    }
+}
+//# sourceMappingURL=workspace-store.js.map

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "clearclaw",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "clearclaw": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "start": "tsx src/index.ts",
+    "dev": "tsc --watch & nodemon --watch dist --exec 'node dist/index.js'",
+    "build": "tsc",
+    "check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.50",
+    "diff": "^8.0.3",
+    "grammy": "^1.30.0",
+    "pino": "^10.3.1",
+    "pino-pretty": "^13.1.3",
+    "pino-roll": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/diff": "^7.0.2",
+    "@types/node": "^22.0.0",
+    "nodemon": "^3.1.14",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}