clearclaw 0.1.0 → 0.2.0

package/dist/channel/telegram.d.ts

@@ -3,10 +3,11 @@ import type { Channel, Button, ButtonResponse, SendMessageOpts } from "../types.
 export declare class TelegramChannel extends EventEmitter implements Channel {
     name: string;
     private bot;
-    private allowedUserId;
+    private allowedUserIds;
     private typingIntervals;
     private pendingCallbacks;
-    constructor(botToken: string, allowedUserId: number);
+    private pendingTextResolvers;
+    constructor(botToken: string, allowedUserIds: Set<string>);
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     ownsId(chatId: string): boolean;

package/dist/channel/telegram.js

@@ -4,22 +4,36 @@ import log from "../logger.js";
 export class TelegramChannel extends EventEmitter {
     name = "telegram";
     bot;
-    allowedUserId;
+    allowedUserIds;
     typingIntervals = new Map();
     // Pending interactive responses: callbackId → resolve function
     pendingCallbacks = new Map();
-    constructor(botToken, allowedUserId) {
+    // Pending text input: chatId → resolve function (for requestText follow-ups)
+    pendingTextResolvers = new Map();
+    constructor(botToken, allowedUserIds) {
         super();
-        this.allowedUserId = allowedUserId;
+        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.allowedUserId)
+            if (!ctx.from?.id || !this.allowedUserIds.has(`tg:${ctx.from.id}`))
                 return;
             const chatId = `tg:${ctx.chat.id}`;
-            this.emit("message", { chatId, text: ctx.message.text });
+            // Intercept for requestText follow-ups before emitting as a new message
+            const textResolver = this.pendingTextResolvers.get(chatId);
+            if (textResolver) {
+                this.pendingTextResolvers.delete(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 });
         });
         // Handle inline keyboard button presses
         this.bot.on("callback_query:data", async (ctx) => {
@@ -76,10 +90,10 @@ export class TelegramChannel extends EventEmitter {
     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) => ({
+        // Pre-compute callback data keys (use index to avoid collisions when buttons share values)
+        const cbEntries = buttons.map((btn, i) => ({
             btn,
-            cbData: `${callbackId}:${btn.value}`,
+            cbData: `${callbackId}:${i}`,
         }));
         // Build inline keyboard
         const keyboard = new InlineKeyboard();
@@ -95,19 +109,32 @@ export class TelegramChannel extends EventEmitter {
             }
         };
         // Wait for button press or timeout (30 minutes)
-        return new Promise((resolve) => {
+        const pressed = await new Promise((resolve) => {
             const timeout = setTimeout(() => {
                 cleanupAll();
-                resolve({ value: "" });
+                resolve(null);
             }, 30 * 60 * 1000);
             for (const { btn, cbData } of cbEntries) {
                 this.pendingCallbacks.set(cbData, () => {
                     clearTimeout(timeout);
                     cleanupAll();
-                    resolve({ value: btn.value });
+                    resolve(btn);
                 });
             }
         });
+        if (!pressed)
+            return { value: "" };
+        // If the button requests text, prompt for follow-up input
+        if (pressed.requestText) {
+            await this.bot.api.sendMessage(numId, "Type your note:", {
+                reply_markup: { force_reply: true },
+            });
+            const followUpText = await new Promise((resolve) => {
+                this.pendingTextResolvers.set(chatId, resolve);
+            });
+            return { value: pressed.value, text: followUpText };
+        }
+        return { value: pressed.value };
     }
     async setTyping(chatId, isTyping) {
         if (isTyping) {

package/dist/config.d.ts

@@ -1,9 +1,10 @@
 import type { PermissionMode } from "./types.js";
 export interface Config {
     botToken: string;
-    allowedUserId: number;
+    allowedUserIds: Set<string>;
     permissionMode: PermissionMode;
     dataDir: string;
+    defaultPromptPath: string;
     workspacesPath: string;
     logPath: string;
 }

package/dist/config.js

@@ -5,10 +5,10 @@ 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 rawIds = process.env.ALLOWED_USER_IDS ?? process.env.ALLOWED_USER_ID;
+    if (!rawIds)
+        throw new Error("Missing required env var: ALLOWED_USER_IDS");
+    const allowedUserIds = new Set(rawIds.split(",").map((s) => s.trim()).filter(Boolean));
     const permissionMode = (process.env.PERMISSION_MODE ?? "default");
     const valid = [
         "default",
@@ -22,9 +22,10 @@ export function loadConfig() {
     }
     return {
         botToken,
-        allowedUserId,
+        allowedUserIds,
         permissionMode,
         dataDir,
+        defaultPromptPath: path.join(dataDir, "workspace", "CLAUDE.md"),
         workspacesPath: path.join(dataDir, "workspaces.json"),
         logPath: path.join(dataDir, "clearclaw.log"),
     };

package/dist/engine/claude-code.js

@@ -4,7 +4,7 @@ import { formatToolDescription } from "../format.js";
 export class ClaudeCodeEngine {
     name = "claude-code";
     async *runTurn(opts) {
-        const { sessionId, cwd, prompt, permissionMode, onPermissionRequest, signal, } = opts;
+        const { sessionId, cwd, prompt, permissionMode, onPermissionRequest, appendSystemPrompt, signal, } = opts;
         const abortController = new AbortController();
         // Wire external signal to our abort controller
         if (signal) {
@@ -26,7 +26,19 @@ export class ClaudeCodeEngine {
             if (resp.decision === "allow") {
                 return { behavior: "allow", updatedInput: input };
             }
-            return { behavior: "deny", message: "User denied" };
+            const denyMessage = resp.message
+                ? `User denied this action with feedback: ${resp.message}`
+                : "User denied";
+            // Deny with note: let the model read the feedback and adjust.
+            // Plain deny: interrupt to stop the turn immediately.
+            // (The SDK has a bug where interrupt causes an unhandled rejection —
+            // handleControlRequest writes to stdin after the subprocess exits.
+            // Suppressed by the unhandledRejection handler in index.ts.)
+            return {
+                behavior: "deny",
+                message: denyMessage,
+                interrupt: !resp.message,
+            };
         };
         const q = query({
             prompt,
@@ -38,6 +50,15 @@ export class ClaudeCodeEngine {
                 canUseTool,
                 abortController,
                 settingSources: ["user", "project", "local"],
+                ...(appendSystemPrompt
+                    ? {
+                        systemPrompt: {
+                            type: "preset",
+                            preset: "claude_code",
+                            append: appendSystemPrompt,
+                        },
+                    }
+                    : {}),
             },
         });
         let resultSessionId;
@@ -112,10 +133,15 @@ export class ClaudeCodeEngine {
             }
         }
         catch (err) {
-            yield {
-                type: "error",
-                message: err instanceof Error ? err.message : String(err),
-            };
+            if (err instanceof Error && err.name === "AbortError") {
+                log.info("[sdk] turn aborted");
+            }
+            else {
+                yield {
+                    type: "error",
+                    message: err instanceof Error ? err.message : String(err),
+                };
+            }
         }
         if (resultSessionId) {
             yield { type: "done", sessionId: resultSessionId };

package/dist/index.js

@@ -5,17 +5,33 @@ import { WorkspaceStore } from "./workspace-store.js";
 import { ClaudeCodeEngine } from "./engine/claude-code.js";
 import { TelegramChannel } from "./channel/telegram.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
+// callback causes an unhandled rejection (write to dead process).
+// Suppress that specific error so we can use abort for deny + /cancel.
+process.on("unhandledRejection", (reason) => {
+    const msg = reason instanceof Error ? reason.message : String(reason);
+    if (msg.includes("Operation aborted") ||
+        msg.includes("Failed to write to process stdin") ||
+        msg.includes("Cannot write to terminated process")) {
+        log.warn("[sdk] suppressed write error (known SDK bug): %s", msg);
+        return;
+    }
+    log.fatal({ err: reason }, "Unhandled rejection");
+    process.exit(1);
+});
 async function main() {
     const config = loadConfig();
     initLogger(config.logPath);
     const workspaceStore = new WorkspaceStore(config.workspacesPath);
-    const channel = new TelegramChannel(config.botToken, config.allowedUserId);
+    const channel = new TelegramChannel(config.botToken, config.allowedUserIds);
     const engine = new ClaudeCodeEngine();
     const orchestrator = new Orchestrator({
         channel,
         engine,
         workspaceStore,
         permissionMode: config.permissionMode,
+        defaultPromptPath: config.defaultPromptPath,
     });
     await orchestrator.start();
 }

package/dist/orchestrator.d.ts

@@ -5,16 +5,21 @@ export interface OrchestratorOpts {
     engine: Engine;
     workspaceStore: WorkspaceStore;
     permissionMode: PermissionMode;
+    defaultPromptPath: string;
 }
 export declare class Orchestrator {
     private channel;
     private engine;
     private workspaceStore;
     private permissionMode;
-    private busyChats;
+    private defaultPromptPath;
+    private chats;
     constructor(opts: OrchestratorOpts);
+    private chat;
     start(): Promise<void>;
     stop(): Promise<void>;
     private handleMessage;
     private routeEngineEvent;
+    /** Read default workspace CLAUDE.md to append to non-default workspace sessions. */
+    private readDefaultPrompt;
 }

package/dist/orchestrator.js

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import path from "node:path";
 import log from "./logger.js";
 import { formatToolUse, formatToolResult } from "./format.js";
 export class Orchestrator {
@@ -5,12 +7,22 @@ export class Orchestrator {
     engine;
     workspaceStore;
     permissionMode;
-    busyChats = new Set();
+    defaultPromptPath;
+    chats = new Map();
     constructor(opts) {
         this.channel = opts.channel;
         this.engine = opts.engine;
         this.workspaceStore = opts.workspaceStore;
         this.permissionMode = opts.permissionMode;
+        this.defaultPromptPath = opts.defaultPromptPath;
+    }
+    chat(chatId) {
+        let s = this.chats.get(chatId);
+        if (!s) {
+            s = { busy: false, abort: null };
+            this.chats.set(chatId, s);
+        }
+        return s;
     }
     async start() {
         this.channel.on("message", (msg) => {
@@ -32,7 +44,8 @@ export class Orchestrator {
     }
     async handleMessage(msg) {
         try {
-            log.info(`[msg] ${msg.text.slice(0, 80)}`);
+            log.info(`[msg] ${msg.user.name} (${msg.user.id}) ${msg.text.slice(0, 80)}`);
+            const state = this.chat(msg.chatId);
             // /new — reset session
             if (msg.text === "/new") {
                 const ws = this.workspaceStore.byChat(msg.chatId);
@@ -45,37 +58,60 @@ export class Orchestrator {
                 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...");
+            // /cancel — abort the running turn
+            if (msg.text === "/cancel") {
+                if (state.abort) {
+                    state.abort.abort();
+                    log.info("[cmd] turn cancelled");
+                }
+                else {
+                    await this.channel.sendMessage(msg.chatId, "Nothing to cancel.");
+                }
                 return;
             }
-            this.busyChats.add(msg.chatId);
+            // Workspace lookup — guard all turn logic below
             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;
             }
+            // Reject during active turn (per-chat)
+            if (state.busy) {
+                log.info("[msg] rejected (busy)");
+                await this.channel.sendMessage(msg.chatId, "Still working on the previous message...");
+                return;
+            }
+            state.busy = true;
+            const abort = new AbortController();
+            state.abort = abort;
             log.info(`[turn] start session=${ws.current_session_id ?? "new"} cwd=${ws.cwd}`);
             await this.channel.setTyping(msg.chatId, true);
+            // Append default workspace CLAUDE.md to non-default workspace sessions
+            const isDefaultWorkspace = ws.cwd === path.dirname(this.defaultPromptPath);
+            const appendSystemPrompt = isDefaultWorkspace ? undefined : this.readDefaultPrompt();
+            // In group workspaces, prepend sender identity so the engine knows who's talking
+            const sender = msg.user.handle ? `${msg.user.name} (@${msg.user.handle})` : msg.user.name;
+            const prompt = isDefaultWorkspace ? msg.text : `[${sender}]: ${msg.text}`;
             try {
                 for await (const event of this.engine.runTurn({
                     sessionId: ws.current_session_id,
                     cwd: ws.cwd,
-                    prompt: msg.text,
+                    prompt,
                     permissionMode: this.permissionMode,
+                    appendSystemPrompt,
+                    signal: abort.signal,
                     onPermissionRequest: async (req) => {
                         log.info(`[perm] ${req.toolName}`);
-                        const resp = await this.channel.sendInteractive(msg.chatId, `Allow ${req.toolName}?`, [
+                        const resp = await this.channel.sendInteractive(msg.chatId, `Allow ${req.toolName}?\n${req.description}`, [
                             { label: "Allow", value: "allow" },
                             { label: "Deny", value: "deny" },
+                            { label: "Deny+Note", value: "deny", requestText: true },
                         ]);
-                        log.info(`[perm] ${req.toolName} → ${resp.value || "timeout"}`);
+                        log.info(`[perm] ${req.toolName} → ${resp.value || "timeout"}${resp.text ? ` "${resp.text}"` : ""}`);
                         return {
                             decision: resp.value === "allow" ? "allow" : "deny",
+                            message: resp.text,
                         };
                     },
                 })) {
@@ -83,8 +119,13 @@ export class Orchestrator {
                 }
             }
             finally {
-                this.busyChats.delete(msg.chatId);
+                const cancelled = abort.signal.aborted;
+                state.busy = false;
+                state.abort = null;
                 await this.channel.setTyping(msg.chatId, false);
+                if (cancelled) {
+                    await this.channel.sendMessage(msg.chatId, "Turn cancelled.");
+                }
             }
         }
         catch (err) {
@@ -131,5 +172,15 @@ export class Orchestrator {
                 break;
         }
     }
+    /** Read default workspace CLAUDE.md to append to non-default workspace sessions. */
+    readDefaultPrompt() {
+        try {
+            const content = fs.readFileSync(this.defaultPromptPath, "utf-8").trim();
+            return content || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
 }
 //# sourceMappingURL=orchestrator.js.map

package/dist/types.d.ts

@@ -17,9 +17,11 @@ export interface Channel {
 export interface Button {
     label: string;
     value: string;
+    requestText?: boolean;
 }
 export interface ButtonResponse {
     value: string;
+    text?: string;
 }
 export interface SendMessageOpts {
     parseMode?: "MarkdownV2" | "HTML";
@@ -34,6 +36,7 @@ export interface RunTurnOpts {
     prompt: string;
     permissionMode: PermissionMode;
     onPermissionRequest: (req: PermissionRequest) => Promise<PermissionResponse>;
+    appendSystemPrompt?: string;
     signal?: AbortSignal;
 }
 export interface PermissionRequest {
@@ -44,6 +47,7 @@ export interface PermissionRequest {
 }
 export interface PermissionResponse {
     decision: "allow" | "deny";
+    message?: string;
 }
 export type EngineEvent = {
     type: "text";
@@ -73,8 +77,14 @@ export interface Workspace {
     chat_id: string;
     current_session_id: string | null;
 }
+export interface UserInfo {
+    id: string;
+    name: string;
+    handle?: string;
+}
 export interface InboundMessage {
     chatId: string;
+    user: UserInfo;
     text: string;
 }
 export type { PermissionMode };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clearclaw",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "bin": {
     "clearclaw": "dist/index.js"
@@ -11,7 +11,8 @@
   ],
   "scripts": {
     "start": "tsx src/index.ts",
-    "dev": "tsc --watch & nodemon --watch dist --exec 'node dist/index.js'",
+    "dev": "tsx --watch src/index.ts",
+    "dev:relay": "nodemon --watch dist --exec 'node dist/index.js'",
     "build": "tsc",
     "check": "tsc --noEmit"
   },