clearclaw 0.6.1 → 0.8.0

package/dist/format.js

@@ -1,9 +1,10 @@
 /**
  * Formatting utilities for Telegram display.
  *
- * Uses the `diff` library for unified diffs in Edit permission prompts.
+ * Uses the `diff` library for interleaved diffs in Edit permission prompts.
  */
-import { createTwoFilesPatch } from "diff";
+import { diffLines } from "diff";
+import { isKnownToolCall } from "./types.js";
 const MAX_LINES = 200;
 const MAX_STATUS_LEN = 60;
 /**
@@ -24,82 +25,82 @@ export function formatToolCallSummary(toolCalls) {
  * Short one-liner for the rolling tool message. Includes key detail
  * but truncated to stay compact.
  */
-export function formatToolStatusLine(toolName, input) {
-    const full = `🔧 ${formatToolStatus(toolName, input)}`;
+export function formatToolStatusLine(tool) {
+    const full = `🔧 ${formatToolStatus(tool)}`;
     if (full.length <= MAX_STATUS_LEN)
         return full;
     return `${full.slice(0, MAX_STATUS_LEN - 1)}…`;
 }
 /**
- * Format a permission prompt for display. Returns a MarkdownV2 string.
- * Edit/Write include the diff/preview; other tools get a one-line description.
+ * Format a permission prompt for display.
+ * Switches on action type: edit shows diff, write shows preview,
+ * execute shows command, others show available detail.
  */
-export function formatPermissionPrompt(toolName, input, description) {
-    if (toolName === "Edit") {
-        const edit = input;
-        const patch = createTwoFilesPatch(`a/${edit.file_path}`, `b/${edit.file_path}`, edit.old_string, edit.new_string, "", "", { context: 3 });
-        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);
-        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 = 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 body = truncateLines(detail.split("\n"), MAX_LINES);
-    return `🔐 Allow ${toolName}?\n\`\`\`\n${body}\n\`\`\``;
+export function formatPermissionPrompt(tool) {
+    const detail = formatToolDetail(tool);
+    if (!detail)
+        return `🔐 Allow ${tool.toolName}?`;
+    return `🔐 Allow ${tool.toolName}?\n${detail}`;
 }
-function formatToolStatus(toolName, input) {
-    switch (toolName) {
-        case "Bash":
-            return `Bash: ${input.command ?? "(unknown)"}`;
-        case "Read":
-            return `Read: ${input.file_path ?? "(unknown)"}`;
-        case "Edit":
-            return `Edit: ${input.file_path ?? "(unknown)"}`;
-        case "Write":
-            return `Write: ${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;
+/** Multi-line detail for permission prompts (diff, content preview, command, etc.). */
+function formatToolDetail(tool) {
+    if (!isKnownToolCall(tool))
+        return formatUnknownDetail(tool);
+    switch (tool.action) {
+        case "edit": {
+            if (!tool.before && !tool.after)
+                return tool.path;
+            const lines = formatInterleavedDiff(tool.before, tool.after);
+            return `${tool.path}\n\`\`\`\n${truncateLines(lines, MAX_LINES)}\n\`\`\``;
+        }
+        case "write": {
+            const lines = tool.content.split("\n");
+            return `${tool.path} (${lines.length} lines)\n\`\`\`\n${truncateLines(lines, MAX_LINES)}\n\`\`\``;
+        }
+        case "execute":
+            return `\`\`\`\n${truncateLines(tool.command.split("\n"), MAX_LINES)}\n\`\`\``;
+        case "read":
+            return `\`\`\`\n${tool.paths.join("\n")}\n\`\`\``;
+        case "search":
+            return `\`\`\`\n${tool.pattern}\n\`\`\``;
+        case "fetch":
+            return `\`\`\`\n${tool.url}\n\`\`\``;
     }
 }
-/** Extract the key detail for a tool's permission prompt (command, query, URL, etc.). */
-function formatToolDetail(toolName, input) {
-    switch (toolName) {
-        case "Bash":
-            return String(input.command ?? "");
-        case "Read":
-        case "Edit":
-        case "Write":
-            return String(input.file_path ?? "");
-        case "Glob":
-        case "Grep":
-            return String(input.pattern ?? "");
-        case "WebSearch":
-            return String(input.query ?? "");
-        case "WebFetch":
-            return String(input.url ?? "");
-        case "Agent":
-            return String(input.description ?? "");
-        default:
-            return JSON.stringify(input, null, 2);
+/** One-liner summary for tool status display. */
+function formatToolStatus(tool) {
+    if (!isKnownToolCall(tool)) {
+        const summary = formatUnknownSummary(tool);
+        return summary ? `${tool.toolName}: ${summary}` : tool.toolName;
     }
+    switch (tool.action) {
+        case "edit":
+        case "write":
+            return `${tool.toolName}: ${tool.path}`;
+        case "execute":
+            return `${tool.toolName}: ${tool.command}`;
+        case "read":
+            return `${tool.toolName}: ${tool.paths.join(", ")}`;
+        case "search":
+            return `${tool.toolName}: ${tool.pattern}`;
+        case "fetch":
+            return `${tool.toolName}: ${tool.url}`;
+    }
+}
+/** Extract displayable info from an unknown tool call's generic fields. */
+function formatUnknownSummary(tool) {
+    const parts = [];
+    if ("paths" in tool && Array.isArray(tool.paths))
+        parts.push(...tool.paths);
+    if ("detail" in tool && tool.detail)
+        parts.push(String(tool.detail));
+    return parts.length > 0 ? parts.join(", ") : null;
+}
+function formatUnknownDetail(tool) {
+    const summary = formatUnknownSummary(tool);
+    if (!summary)
+        return null;
+    return `\`\`\`\n${truncateLines(summary.split("\n"), MAX_LINES)}\n\`\`\``;
 }
 /**
  * Relative time string: "just now", "5m ago", "2h ago", "3d ago".
@@ -145,7 +146,7 @@ export function truncateButtonLabel(index, label) {
  * Format an ExitPlanMode permission prompt.
  * Renders plan text from the description or input fields.
  */
-export function formatExitPlanMode(input, description) {
+export function formatExitPlanMode(input) {
     const plan = (typeof input.plan === "string" ? input.plan : null)
         || JSON.stringify(input, null, 2);
     const lines = plan.split("\n");
@@ -176,19 +177,42 @@ function truncateLines(lines, max) {
     const remaining = lines.length - max;
     return `${shown}\n... (${remaining} more lines)`;
 }
-/**
- * Human-readable one-liner for a tool invocation (used in engine's canUseTool).
- */
-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}?`;
+/** Build an interleaved diff with clear separator between markers and content. */
+function formatInterleavedDiff(before, after) {
+    const changes = diffLines(before, after);
+    const lines = [];
+    const splitValue = (value) => value.replace(/\n$/, "").split("\n");
+    for (let i = 0; i < changes.length; i++) {
+        const c = changes[i];
+        if (c.removed) {
+            const next = changes[i + 1];
+            if (next?.added) {
+                // Interleave paired removals and additions line by line
+                const remLines = splitValue(c.value);
+                const addLines = splitValue(next.value);
+                const max = Math.max(remLines.length, addLines.length);
+                for (let j = 0; j < max; j++) {
+                    if (j < remLines.length)
+                        lines.push(`- │ ${remLines[j]}`);
+                    if (j < addLines.length)
+                        lines.push(`+ │ ${addLines[j]}`);
+                }
+                i++; // skip the paired added chunk
+            }
+            else {
+                for (const l of splitValue(c.value))
+                    lines.push(`- │ ${l}`);
+            }
+        }
+        else if (c.added) {
+            for (const l of splitValue(c.value))
+                lines.push(`+ │ ${l}`);
+        }
+        else {
+            for (const l of splitValue(c.value))
+                lines.push(`· │ ${l}`);
+        }
     }
+    return lines;
 }
 //# sourceMappingURL=format.js.map

package/dist/index.js

@@ -2,13 +2,12 @@
 import readline from "node:readline";
 import { Config } from "./config.js";
 import log, { initLogger } from "./logger.js";
-import { ClaudeCodeEngine } from "./engine/claude-code.js";
+import { createEngineMap, ENGINE_NAMES, resolveEnginePath } from "./engine/registry.js";
 import { TelegramChannel } from "./channel/telegram.js";
 import { SlackChannel } from "./channel/slack.js";
 import { Orchestrator } from "./orchestrator.js";
 async function runDaemon() {
     const config = new Config().resolve();
-    config.syncSkills();
     initLogger(config.logPath);
     // The Claude Agent SDK has a bug: handleControlRequest() writes to the
     // subprocess stdin without a .catch(), so aborting during a permission
@@ -41,8 +40,8 @@ async function runDaemon() {
             log.warn({ err }, "[pairing] failed to send pairing message");
         });
     };
-    const channel = createChannel(config.channel, (userId) => config.isAuthorized(userId), onUnauthorizedDM);
-    await new Orchestrator({ channel, engine: new ClaudeCodeEngine(), config }).start();
+    const channel = createChannel(config.channel, (userId) => config.isAuthorized(userId), onUnauthorizedDM, () => config.listAuthorizedUserIds());
+    await new Orchestrator({ channel, engines: createEngineMap(config.engines), config }).start();
 }
 async function runApprove(args) {
     const code = args[0];
@@ -56,7 +55,9 @@ async function runApprove(args) {
         console.error("Invalid or expired pairing code.");
         process.exit(1);
     }
-    config.approveUser(pairing.userId, pairing.userName, pairing.chatId);
+    config.approveUser(pairing.userId, pairing.userName);
+    // Pairings only originate from a root DM, so this chat is home's destination.
+    config.connectHomeWorkspace(pairing.chatId);
     console.log(`Approved ${pairing.userName} (${pairing.userId})`);
 }
 const SETUP_TIMEOUT_MS = 5 * 60 * 1000;
@@ -87,15 +88,36 @@ async function runSetup() {
                 throw new Error("Bot token required.");
             channelConfig = { type: "telegram", botToken };
         }
+        let engineName;
+        let resolvedPath;
+        const engineList = ENGINE_NAMES.join("/");
+        while (true) {
+            engineName = (await ask(`Default engine [${engineList}]: `)).trim().toLowerCase();
+            if (!ENGINE_NAMES.includes(engineName)) {
+                console.log(`  Please enter one of: ${engineList}`);
+                continue;
+            }
+            try {
+                resolvedPath = resolveEnginePath(engineName);
+                break;
+            }
+            catch (err) {
+                console.log(`  ${err.message}`);
+            }
+        }
         const config = new Config();
         config.setChannel(channelConfig);
+        config.setEngines([
+            { name: engineName, default: true, path: resolvedPath },
+        ]);
         console.log("Saved to ~/.clearclaw/config.json\n");
         config.resolve();
+        config.ensureHomeWorkspace();
         let resolveFirstDM;
         const firstDM = new Promise((r) => {
             resolveFirstDM = r;
         });
-        channel = createChannel(config.channel, (userId) => config.isAuthorized(userId), (chatId, user) => resolveFirstDM({ chatId, user }));
+        channel = createChannel(config.channel, (userId) => config.isAuthorized(userId), (chatId, user) => resolveFirstDM({ chatId, user }), () => config.listAuthorizedUserIds());
         console.log("Connecting...");
         await channel.connect();
         console.log("Connected! Waiting for a DM — message the bot from your chat app.\n");
@@ -118,7 +140,9 @@ async function runSetup() {
             await channel.sendMessage(chatId, "Pairing code was invalid. Please try again.");
             return;
         }
-        config.approveUser(pairing.userId, pairing.userName, pairing.chatId);
+        config.approveUser(pairing.userId, pairing.userName);
+        // Pairings only originate from a root DM, so this chat is home's destination.
+        config.connectHomeWorkspace(pairing.chatId);
         console.log(`  Approved ${pairing.userName} (${pairing.userId})`);
         await channel.sendMessage(chatId, "You're approved! The bot is being set up — you'll be able to chat soon.");
         console.log("\nSetup complete! Start the daemon:\n  clearclaw daemon\n");
@@ -129,9 +153,9 @@ async function runSetup() {
         rl.close();
     }
 }
-function createChannel(ch, isAuthorized, onUnauthorizedDM) {
+function createChannel(ch, isAuthorized, onUnauthorizedDM, authorizedUserIds) {
     if (ch.type === "slack") {
-        return new SlackChannel(ch.botToken, ch.appToken, isAuthorized, onUnauthorizedDM);
+        return new SlackChannel(ch.botToken, ch.appToken, isAuthorized, onUnauthorizedDM, authorizedUserIds);
     }
     return new TelegramChannel(ch.botToken, isAuthorized, onUnauthorizedDM);
 }

package/dist/orchestrator.d.ts

@@ -1,32 +1,58 @@
 import type { Config } from "./config.js";
-import type { Channel, Engine } from "./types.js";
+import type { Channel, Engine, InboundMessage, MessageOrigin } from "./types.js";
 export interface OrchestratorOpts {
     channel: Channel;
-    engine: Engine;
+    engines: Map<string, Engine>;
     config: Config;
 }
 export declare class Orchestrator {
     private channel;
-    private engine;
+    private engines;
     private config;
     private chats;
-    private tasks;
+    private creatingWorkspaces;
+    private scheduler;
+    private planUsage;
     constructor(opts: OrchestratorOpts);
     private chat;
+    private engineFor;
     start(): Promise<void>;
     stop(): Promise<void>;
-    /** Effective behavior: tasks→assistant, workspace→explicit setting or home→assistant / project→relay. */
+    /** Deliver a synthetic message to a named workspace and trigger its turn. */
+    deliverToWorkspace(workspaceName: string, origin: MessageOrigin, text: string): boolean;
+    /**
+     * Everything creation can reject without touching the platform. Runs before the
+     * confirmation, so the user is never asked to approve a doomed spawn, and again
+     * inside creation, where it is the authoritative check.
+     */
+    private validateNewWorkspace;
+    /** Shared creation path for standalone projects and peers, with optional manual binding. */
+    private createWorkspace;
+    /** Grouping is best-effort: it never fails a lifecycle operation, but it is never silent either. */
+    private groupChat;
+    private deliverInitialBrief;
+    /** An unbound chat can connect without starting a temporary agent or sharing home's session. */
+    private connectWorkspace;
+    private peerRuntime;
+    /** Effective behavior: Explicit setting or home→assistant / project→relay. */
     private effectiveBehavior;
-    /** Enqueue a message and drain — immediately for relay, debounced for assistant/task. */
+    /** Permission mode a chat runs in until /mode picks one. */
+    private baseMode;
+    /** Enqueue a message and drain — immediately for relay, debounced for assistant. */
     private enqueueMessage;
     private scheduleDebounce;
     private processQueuedMessages;
     private executeTurn;
+    private persistSessionId;
+    /** Native selection works even when the workspace's engine cannot run. */
+    private selectEngine;
     private routeMessage;
     private routeEngineEvent;
+    private routeTextChunk;
+    private publishTextSegment;
+    private flushTextSegment;
     private buildMcpTools;
     private handlePermission;
     private updateStatusMessage;
-    /** Read default workspace CLAUDE.md to append to non-default workspace sessions. */
-    private readDefaultPrompt;
 }
+export declare function buildPrompt(messages: InboundMessage[]): string;