clearclaw 0.3.0 → 0.5.0

package/dist/orchestrator.d.ts

@@ -6,6 +6,7 @@ export interface OrchestratorOpts {
     workspaceStore: WorkspaceStore;
     permissionMode: PermissionMode;
     defaultPromptPath: string;
+    filesPath: string;
 }
 export declare class Orchestrator {
     private channel;
@@ -13,6 +14,7 @@ export declare class Orchestrator {
     private workspaceStore;
     private permissionMode;
     private defaultPromptPath;
+    private filesPath;
     private chats;
     constructor(opts: OrchestratorOpts);
     private chat;
@@ -21,7 +23,6 @@ export declare class Orchestrator {
     private handleMessage;
     private routeEngineEvent;
     private updateStatusMessage;
-    private clearStatusMessage;
     /** Read default workspace CLAUDE.md to append to non-default workspace sessions. */
     private readDefaultPrompt;
 }

package/dist/orchestrator.js

@@ -1,7 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
 import log from "./logger.js";
-import { formatToolStatusLine, formatToolCallSummary, formatPermissionPrompt } from "./format.js";
+import { saveFile } from "./files.js";
+import { formatToolStatusLine, formatToolCallSummary, formatPermissionPrompt, timeAgo } from "./format.js";
 const MODE_OPTIONS = [
     { label: "Default", value: "default" },
     { label: "Accept Edits", value: "acceptEdits" },
@@ -14,6 +17,7 @@ export class Orchestrator {
     workspaceStore;
     permissionMode;
     defaultPromptPath;
+    filesPath;
     chats = new Map();
     constructor(opts) {
         this.channel = opts.channel;
@@ -21,12 +25,13 @@ export class Orchestrator {
         this.workspaceStore = opts.workspaceStore;
         this.permissionMode = opts.permissionMode;
         this.defaultPromptPath = opts.defaultPromptPath;
+        this.filesPath = opts.filesPath;
     }
     chat(chatId) {
         let s = this.chats.get(chatId);
         if (!s) {
             s = {
-                busy: false, abort: null, permissionMode: null, statusHandle: null, stats: null,
+                busy: false, abort: null, permissionMode: null, stats: null, lastStatusText: null,
                 toolCallHandle: null,
             };
             this.chats.set(chatId, s);
@@ -91,6 +96,51 @@ export class Orchestrator {
                 await this.channel.sendMessage(msg.chatId, "Session cleared.");
                 return;
             }
+            // /resume — switch to a previous session
+            if (msg.text === "/resume") {
+                if (state.busy) {
+                    await this.channel.sendMessage(msg.chatId, "A turn is in progress. Wait for it to finish before switching sessions.");
+                    return;
+                }
+                const ws = this.workspaceStore.byChat(msg.chatId);
+                if (!ws) {
+                    await this.channel.sendMessage(msg.chatId, "No workspace linked to this group.");
+                    return;
+                }
+                const sessions = await this.engine.listSessions(ws.cwd);
+                if (sessions.length === 0) {
+                    await this.channel.sendMessage(msg.chatId, "No sessions found for this workspace.");
+                    return;
+                }
+                const MAX_BTN = 45;
+                // Strip ClearClaw's "[User (@handle)]: " prefix from SDK summaries
+                const stripped = sessions.map((s) => ({
+                    ...s,
+                    summary: s.summary.replace(/^\[.*?\]:\s*/, ""),
+                }));
+                // Build detailed list for message body
+                const listing = stripped.map((s, i) => {
+                    const current = s.sessionId === ws.current_session_id ? " ✅" : "";
+                    const meta = [timeAgo(s.lastModified), s.gitBranch].filter(Boolean).join(" · ");
+                    return `${i + 1}. ${s.summary}${current}\n   ${meta}`;
+                }).join("\n");
+                // Concise button labels (single line)
+                const buttons = stripped.map((s, i) => {
+                    const label = `${i + 1}. ${s.summary}`;
+                    const truncated = label.length > MAX_BTN
+                        ? label.slice(0, MAX_BTN - 1) + "…"
+                        : label;
+                    return [{ label: truncated, value: s.sessionId }];
+                });
+                const resp = await this.channel.sendInteractive(msg.chatId, `Pick a session to resume:\n\n${listing}`, buttons);
+                if (resp.value) {
+                    this.workspaceStore.setSession(ws.name, resp.value);
+                    const picked = stripped.find((s) => s.sessionId === resp.value);
+                    await this.channel.sendMessage(msg.chatId, `Resumed session: ${picked?.summary ?? resp.value}`);
+                    log.info("[cmd] resumed session %s for workspace %s", resp.value, ws.name);
+                }
+                return;
+            }
             // /cancel — abort the running turn
             if (msg.text === "/cancel") {
                 if (state.abort) {
@@ -126,31 +176,78 @@ export class Orchestrator {
             // 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}`;
+            // Save attachments to disk for the audit log (failures must not block the turn)
+            if (msg.attachments?.length) {
+                const results = await Promise.allSettled(msg.attachments.map((att) => saveFile(att, ws.name, this.filesPath)));
+                for (const r of results) {
+                    if (r.status === "rejected")
+                        log.warn({ err: r.reason }, "[turn] failed to save attachment");
+                }
+                const saved = results.filter((r) => r.status === "fulfilled").length;
+                if (saved > 0)
+                    log.info("[turn] saved %d/%d attachment(s) for workspace %s", saved, msg.attachments.length, ws.name);
+            }
+            const mcpServer = createSdkMcpServer({
+                name: "clearclaw",
+                tools: [
+                    tool("send_file", "Send a file or image to the current chat conversation", {
+                        file_path: z.string().optional().describe("Absolute path to the file to send"),
+                        data: z.string().optional().describe("Base64-encoded file data (alternative to file_path)"),
+                        filename: z.string().optional().describe("Filename (required when using data, optional with file_path)"),
+                        caption: z.string().optional().describe("Optional caption to accompany the file"),
+                    }, async (args) => {
+                        if (!args.file_path && !args.data)
+                            throw new Error("Either file_path or data must be provided");
+                        const buffer = args.file_path
+                            ? await fs.promises.readFile(args.file_path)
+                            : Buffer.from(args.data, "base64");
+                        const name = args.filename ?? path.basename(args.file_path ?? "file");
+                        await this.channel.sendFile(msg.chatId, buffer, name, { caption: args.caption });
+                        return { content: [{ type: "text", text: `Sent ${name} to chat` }] };
+                    }),
+                ],
+            });
             try {
                 for await (const event of this.engine.runTurn({
                     sessionId: ws.current_session_id,
                     cwd: ws.cwd,
                     prompt,
+                    attachments: msg.attachments,
                     permissionMode: state.permissionMode ?? this.permissionMode,
                     appendSystemPrompt,
+                    mcpServers: { clearclaw: mcpServer },
                     signal: abort.signal,
                     onPermissionRequest: async (req) => {
+                        // Auto-allow ClearClaw's own MCP tools — no chat prompt needed
+                        if (req.toolName.startsWith("mcp__clearclaw__")) {
+                            log.info(`[perm] ${req.toolName} → auto-allow`);
+                            return { decision: "allow" };
+                        }
                         log.info(`[perm] ${req.toolName}`);
-                        const promptText = formatPermissionPrompt(req.toolName, req.input, req.description);
-                        const resp = await this.channel.sendInteractive(msg.chatId, promptText, [
-                            [
-                                { label: "👍 Allow", value: "allow" },
-                                { label: "👎 Deny", value: "deny" },
-                            ],
-                            [
-                                { label: "📝 Deny + Note", value: "deny", requestText: true },
-                            ],
-                        ], { parseMode: "MarkdownV2" });
-                        log.info(`[perm] ${req.toolName} → ${resp.value || "timeout"}${resp.text ? ` "${resp.text}"` : ""}`);
-                        return {
-                            decision: resp.value === "allow" ? "allow" : "deny",
-                            message: resp.text,
-                        };
+                        try {
+                            const promptText = formatPermissionPrompt(req.toolName, req.input, req.description);
+                            const resp = await this.channel.sendInteractive(msg.chatId, promptText, [
+                                [
+                                    { label: "👍 Allow", value: "allow" },
+                                    { label: "👎 Deny", value: "deny" },
+                                ],
+                                [
+                                    { label: "📝 Deny + Note", value: "deny", requestText: true },
+                                ],
+                            ]);
+                            log.info(`[perm] ${req.toolName} → ${resp.value || "timeout"}${resp.text ? ` "${resp.text}"` : ""}`);
+                            return {
+                                decision: resp.value === "allow" ? "allow" : "deny",
+                                message: resp.text,
+                            };
+                        }
+                        catch (err) {
+                            log.warn({ err }, "[perm] failed to send prompt for %s, auto-denying", req.toolName);
+                            return {
+                                decision: "deny",
+                                message: "Permission prompt could not be delivered to chat — denied automatically.",
+                            };
+                        }
                     },
                 })) {
                     await this.routeEngineEvent(msg.chatId, event, ws.name);
@@ -173,113 +270,89 @@ export class Orchestrator {
     }
     async routeEngineEvent(chatId, event, workspaceName) {
         const state = this.chat(chatId);
-        switch (event.type) {
-            case "text":
-                await this.channel.sendMessage(chatId, event.text);
-                break;
-            case "tool_use": {
-                // Rolling message: each tool_use replaces the single message's content
-                const line = formatToolStatusLine(event.toolName, event.input);
-                if (state.toolCallHandle) {
-                    try {
-                        await this.channel.editMessage(chatId, state.toolCallHandle, line);
+        try {
+            switch (event.type) {
+                case "text":
+                    await this.channel.sendMessage(chatId, event.text);
+                    break;
+                case "tool_use": {
+                    // Rolling message: each tool_use replaces the single message's content
+                    const line = formatToolStatusLine(event.toolName, event.input);
+                    if (state.toolCallHandle) {
+                        try {
+                            await this.channel.editMessage(chatId, state.toolCallHandle, line);
+                        }
+                        catch {
+                            const handles = await this.channel.sendMessage(chatId, line, { consumeTyping: false });
+                            state.toolCallHandle = handles[0];
+                        }
                     }
-                    catch {
-                        const handles = await this.channel.sendMessage(chatId, line);
+                    else {
+                        const handles = await this.channel.sendMessage(chatId, line, { consumeTyping: false });
                         state.toolCallHandle = handles[0];
                     }
+                    break;
                 }
-                else {
-                    const handles = await this.channel.sendMessage(chatId, line);
-                    state.toolCallHandle = handles[0];
+                case "tool_result":
+                    // All tool results suppressed — Claude summarizes in its text response
+                    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;
                 }
-                break;
-            }
-            case "tool_result":
-                // All tool results suppressed — Claude summarizes in its text response
-                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": {
-                // Edit rolling tool message to show summary
-                if (state.toolCallHandle && event.stats) {
-                    const summary = formatToolCallSummary(event.stats.toolCalls);
-                    if (summary) {
-                        try {
-                            await this.channel.editMessage(chatId, state.toolCallHandle, summary);
+                case "done": {
+                    // Persist state first — channel calls below are best-effort
+                    log.info(`[turn] done session=${event.sessionId}`);
+                    this.workspaceStore.setSession(workspaceName, event.sessionId);
+                    if (event.stats)
+                        state.stats = event.stats;
+                    // Best-effort: update tool summary and status message
+                    if (state.toolCallHandle && event.stats) {
+                        const summary = formatToolCallSummary(event.stats.toolCalls);
+                        if (summary) {
+                            try {
+                                await this.channel.editMessage(chatId, state.toolCallHandle, summary);
+                            }
+                            catch { /* edit failed, leave as-is */ }
                         }
-                        catch { /* edit failed, leave as-is */ }
                     }
+                    state.toolCallHandle = null;
+                    await this.updateStatusMessage(chatId, state);
+                    break;
                 }
-                state.toolCallHandle = null;
-                log.info(`[turn] done session=${event.sessionId}`);
-                this.workspaceStore.setSession(workspaceName, event.sessionId);
-                if (event.stats)
-                    state.stats = event.stats;
-                await this.updateStatusMessage(chatId, state);
-                break;
+                case "error":
+                    log.error(`[turn] error: ${event.message}`);
+                    await this.channel.sendMessage(chatId, `Error: ${event.message}`);
+                    break;
             }
-            case "error":
-                log.error(`[turn] error: ${event.message}`);
-                await this.channel.sendMessage(chatId, `Error: ${event.message}`);
-                break;
+        }
+        catch (err) {
+            // Channel errors must never propagate — they'd crash the engine turn loop,
+            // killing the SDK session and losing the session ID.
+            log.warn({ err }, "[route] failed to relay %s event to channel", event.type);
         }
     }
     async updateStatusMessage(chatId, state) {
         const mode = state.permissionMode ?? this.permissionMode;
         const modeLabel = MODE_OPTIONS.find((o) => o.value === mode)?.label ?? mode;
-        const parts = [];
+        let text;
         if (state.stats) {
             const pct = state.stats.contextWindow > 0
                 ? Math.round((state.stats.contextUsed / state.stats.contextWindow) * 100)
                 : 0;
-            parts.push(`🤖 ${formatModelName(state.stats.model)} ${pct}% | 🔒 ${modeLabel}`);
+            text = `🤖 ${formatModelName(state.stats.model)} ${pct}% | 🔒 ${modeLabel}`;
         }
         else {
-            parts.push(`🔒 ${modeLabel}`);
-        }
-        const text = parts.join("\n");
-        if (state.statusHandle) {
-            try {
-                await this.channel.editMessage(chatId, state.statusHandle, text);
-            }
-            catch (err) {
-                if (!(err instanceof Error && err.message.includes("message is not modified")))
-                    throw err;
-            }
+            text = `🔒 ${modeLabel}`;
         }
-        else {
-            // Clear stale pins from previous server runs
-            try {
-                await this.channel.unpinAllMessages(chatId);
-            }
-            catch { /* not admin */ }
-            const handles = await this.channel.sendMessage(chatId, text);
-            state.statusHandle = handles[0];
-            try {
-                await this.channel.pinMessage(chatId, state.statusHandle);
-            }
-            catch (err) {
-                log.warn("[cmd] failed to pin status message (bot may not be admin): %s", err instanceof Error ? err.message : String(err));
-            }
-        }
-    }
-    async clearStatusMessage(chatId, state) {
-        if (!state.statusHandle)
+        if (text === state.lastStatusText)
             return;
-        try {
-            await this.channel.deleteMessage(chatId, state.statusHandle);
-        }
-        catch (err) {
-            log.warn("[cmd] failed to delete status message: %s", err instanceof Error ? err.message : String(err));
-        }
-        state.statusHandle = null;
+        await this.channel.updateStatus(chatId, text);
+        state.lastStatusText = text;
     }
     /** Read default workspace CLAUDE.md to append to non-default workspace sessions. */
     readDefaultPrompt() {

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { PermissionMode } from "@anthropic-ai/claude-agent-sdk";
+import type { McpServerConfig, PermissionMode } from "@anthropic-ai/claude-agent-sdk";
 export interface ChannelEvents {
     message: [msg: InboundMessage];
 }
@@ -8,12 +8,14 @@ export interface Channel {
     disconnect(): Promise<void>;
     ownsId(chatId: string): boolean;
     sendMessage(chatId: string, text: string, opts?: SendMessageOpts): Promise<string[]>;
-    sendInteractive(chatId: string, text: string, buttons: Button[][], opts?: SendInteractiveOpts): Promise<ButtonResponse>;
+    sendInteractive(chatId: string, text: string, buttons: Button[][]): Promise<ButtonResponse>;
     editMessage(chatId: string, handle: string, text: string): Promise<void>;
     deleteMessage(chatId: string, handle: string): Promise<void>;
     pinMessage(chatId: string, handle: string): Promise<void>;
     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>;
     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;
@@ -29,21 +31,33 @@ export interface ButtonResponse {
 }
 export interface SendMessageOpts {
     parseMode?: "MarkdownV2" | "HTML";
+    /** When false, skip consuming the typing placeholder (e.g. for tool status messages). */
+    consumeTyping?: boolean;
 }
-export interface SendInteractiveOpts {
-    parseMode?: "MarkdownV2" | "HTML";
+export interface SendFileOpts {
+    caption?: string;
+    mimeType?: string;
+}
+export interface SessionInfo {
+    sessionId: string;
+    summary: string;
+    lastModified: number;
+    gitBranch?: string;
 }
 export interface Engine {
     name: string;
     runTurn(opts: RunTurnOpts): AsyncIterable<EngineEvent>;
+    listSessions(cwd: string): Promise<SessionInfo[]>;
 }
 export interface RunTurnOpts {
     sessionId: string | null;
     cwd: string;
     prompt: string;
+    attachments?: Attachment[];
     permissionMode: PermissionMode;
     onPermissionRequest: (req: PermissionRequest) => Promise<PermissionResponse>;
     appendSystemPrompt?: string;
+    mcpServers?: Record<string, McpServerConfig>;
     signal?: AbortSignal;
 }
 export interface PermissionRequest {
@@ -98,9 +112,16 @@ export interface UserInfo {
     name: string;
     handle?: string;
 }
+/** File data from a channel, kept in memory for engine consumption. */
+export interface Attachment {
+    buffer: Buffer;
+    mimeType: string;
+    filename?: string;
+}
 export interface InboundMessage {
     chatId: string;
     user: UserInfo;
     text: string;
+    attachments?: Attachment[];
 }
 export type { PermissionMode };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clearclaw",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Your coding agent, from your phone — personal assistant + project workspaces on your machine, built on the CLI's permissions, config, and memory instead of replacing them.",
   "type": "module",
   "license": "MIT",
@@ -37,13 +37,16 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.50",
+    "@slack/bolt": "^4.6.0",
     "diff": "^8.0.3",
     "grammy": "^1.30.0",
+    "mime": "^4.1.0",
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
     "pino-roll": "^4.0.0"
   },
   "devDependencies": {
+    "@anthropic-ai/sdk": "^0.78.0",
     "@types/diff": "^7.0.2",
     "@types/node": "^22.0.0",
     "nodemon": "^3.1.14",