clearclaw 0.6.0 → 0.7.0

package/dist/engine/async-queue.js

@@ -0,0 +1,45 @@
+/**
+ * Bridges callback-driven event producers to AsyncIterable consumers.
+ *
+ * Used by AcpEngine to convert ACP's sessionUpdate callbacks into
+ * the AsyncIterable<EngineEvent> that ClearClaw's Engine interface requires.
+ */
+export class AsyncQueue {
+    buffer = [];
+    waiting = [];
+    closed = false;
+    push(value) {
+        if (this.closed)
+            return;
+        const waiter = this.waiting.shift();
+        if (waiter) {
+            waiter({ value, done: false });
+        }
+        else {
+            this.buffer.push(value);
+        }
+    }
+    close() {
+        this.closed = true;
+        for (const waiter of this.waiting) {
+            waiter({ value: undefined, done: true });
+        }
+        this.waiting.length = 0;
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                if (this.buffer.length > 0) {
+                    return Promise.resolve({ value: this.buffer.shift(), done: false });
+                }
+                if (this.closed) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                return new Promise((resolve) => {
+                    this.waiting.push(resolve);
+                });
+            },
+        };
+    }
+}
+//# sourceMappingURL=async-queue.js.map

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

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

package/dist/engine/claude-code.js

@@ -1,8 +1,58 @@
 import { query, listSessions, } from "@anthropic-ai/claude-agent-sdk";
 import log from "../logger.js";
-import { formatToolDescription } from "../format.js";
+/** Map Claude Code SDK tool call to ToolCall. */
+function toToolCall(toolName, input, toolUseId) {
+    switch (toolName) {
+        case "Edit":
+            return {
+                action: "edit", toolName, toolUseId,
+                path: String(input.file_path ?? ""),
+                before: String(input.old_string ?? ""),
+                after: String(input.new_string ?? ""),
+            };
+        case "Write":
+            return {
+                action: "write", toolName, toolUseId,
+                path: String(input.file_path ?? ""),
+                content: String(input.content ?? ""),
+            };
+        case "Bash":
+            return {
+                action: "execute", toolName, toolUseId,
+                command: String(input.command ?? ""),
+            };
+        case "Read":
+        case "Glob":
+            return {
+                action: "read", toolName, toolUseId,
+                paths: [String(input.file_path ?? input.pattern ?? "")],
+            };
+        case "Grep":
+            return {
+                action: "search", toolName, toolUseId,
+                pattern: String(input.pattern ?? ""),
+                paths: input.path ? [String(input.path)] : undefined,
+            };
+        case "WebSearch":
+            return {
+                action: "search", toolName, toolUseId,
+                pattern: String(input.query ?? ""),
+            };
+        case "WebFetch":
+            return {
+                action: "fetch", toolName, toolUseId,
+                url: String(input.url ?? ""),
+            };
+        default:
+            return { action: "other", toolName, toolUseId, ...input };
+    }
+}
 export class ClaudeCodeEngine {
+    executablePath;
     name = "claude-code";
+    constructor(executablePath) {
+        this.executablePath = executablePath;
+    }
     async listSessions(cwd) {
         const sessions = await listSessions({ dir: cwd, limit: 10 });
         return sessions
@@ -27,14 +77,7 @@ export class ClaudeCodeEngine {
             ? { resume: sessionId }
             : {};
         const canUseTool = async (toolName, input, options) => {
-            const description = formatToolDescription(toolName, input);
-            const resp = await onPermissionRequest({
-                toolName,
-                input,
-                description,
-                reason: options.decisionReason,
-                toolUseId: options.toolUseID,
-            });
+            const resp = await onPermissionRequest(toToolCall(toolName, input, options.toolUseID));
             if (resp.decision === "allow") {
                 return { behavior: "allow", updatedInput: resp.updatedInput ?? input };
             }
@@ -63,6 +106,7 @@ export class ClaudeCodeEngine {
                 ...sessionOpts,
                 cwd,
                 permissionMode,
+                ...(this.executablePath ? { pathToClaudeCodeExecutable: this.executablePath } : {}),
                 allowDangerouslySkipPermissions: permissionMode === "bypassPermissions" ? true : undefined,
                 canUseTool: permissionMode === "bypassPermissions" ? undefined : canUseTool,
                 abortController,
@@ -110,9 +154,7 @@ export class ClaudeCodeEngine {
                             toolUseIdToName.set(toolUseId, block.name);
                             yield {
                                 type: "tool_use",
-                                toolName: block.name,
-                                input: block.input,
-                                toolUseId,
+                                tool: toToolCall(block.name, block.input, toolUseId),
                             };
                         }
                     }

package/dist/engine/registry.d.ts

@@ -0,0 +1,16 @@
+import type { Engine } from "../types.js";
+export interface SpawnConfig {
+    command: string;
+    args: string[];
+}
+/** All known engine names (for validation / setup prompts). */
+export declare const ENGINE_NAMES: readonly ["claude-code", ...string[]];
+/** Return the CLI command an engine needs on PATH. */
+export declare function engineCommand(name: string): string | undefined;
+/**
+ * Build the engine map: claude-code (Agent SDK) + known ACP agents.
+ * Engines are lightweight — they store config, not running processes.
+ *
+ * @param enginePaths - resolved executable paths from config (e.g. { "claude-code": "/usr/local/bin/claude" })
+ */
+export declare function createEngineMap(enginePaths?: Record<string, string>): Map<string, Engine>;

package/dist/engine/registry.js

@@ -0,0 +1,32 @@
+import { ClaudeCodeEngine } from "./claude-code.js";
+import { AcpEngine } from "./acp.js";
+/** Known ACP agent spawn configurations. */
+const KNOWN_ACP_AGENTS = {
+    kiro: { command: "kiro-cli", args: ["acp"] },
+};
+/** All known engine names (for validation / setup prompts). */
+export const ENGINE_NAMES = ["claude-code", ...Object.keys(KNOWN_ACP_AGENTS)];
+/** CLI binary each engine needs on PATH. */
+const ENGINE_COMMANDS = {
+    "claude-code": "claude",
+    ...Object.fromEntries(Object.entries(KNOWN_ACP_AGENTS).map(([name, cfg]) => [name, cfg.command])),
+};
+/** Return the CLI command an engine needs on PATH. */
+export function engineCommand(name) {
+    return ENGINE_COMMANDS[name];
+}
+/**
+ * Build the engine map: claude-code (Agent SDK) + known ACP agents.
+ * Engines are lightweight — they store config, not running processes.
+ *
+ * @param enginePaths - resolved executable paths from config (e.g. { "claude-code": "/usr/local/bin/claude" })
+ */
+export function createEngineMap(enginePaths = {}) {
+    const engines = new Map();
+    engines.set("claude-code", new ClaudeCodeEngine(enginePaths["claude-code"]));
+    for (const [name, config] of Object.entries(KNOWN_ACP_AGENTS)) {
+        engines.set(name, new AcpEngine(name, config));
+    }
+    return engines;
+}
+//# sourceMappingURL=registry.js.map

package/dist/format.d.ts

@@ -3,6 +3,7 @@
  *
  * Uses the `diff` library for unified diffs in Edit permission prompts.
  */
+import { type ToolCall } from "./types.js";
 /**
  * Summary line for the rolling tool message after a turn completes.
  * e.g. "🔧 3× Read, 2× Grep, 1× Bash"
@@ -12,12 +13,13 @@ export declare function formatToolCallSummary(toolCalls: Record<string, number>)
  * Short one-liner for the rolling tool message. Includes key detail
  * but truncated to stay compact.
  */
-export declare function formatToolStatusLine(toolName: string, input: Record<string, unknown>): string;
+export declare function formatToolStatusLine(tool: ToolCall): string;
 /**
- * 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 declare function formatPermissionPrompt(toolName: string, input: Record<string, unknown>, description: string): string;
+export declare function formatPermissionPrompt(tool: ToolCall): string;
 /**
  * Relative time string: "just now", "5m ago", "2h ago", "3d ago".
  */
@@ -42,13 +44,9 @@ export declare function truncateButtonLabel(index: number, label: string): strin
  * Format an ExitPlanMode permission prompt.
  * Renders plan text from the description or input fields.
  */
-export declare function formatExitPlanMode(input: Record<string, unknown>, description: string): string;
+export declare function formatExitPlanMode(input: Record<string, unknown>): string;
 /**
  * Format a TodoWrite task list for display.
  */
 export declare function formatTodoList(input: Record<string, unknown>): string;
-/**
- * Human-readable one-liner for a tool invocation (used in engine's canUseTool).
- */
-export declare function formatToolDescription(toolName: string, input: Record<string, unknown>): string;
 export {};

package/dist/format.js

@@ -4,6 +4,7 @@
  * Uses the `diff` library for unified diffs in Edit permission prompts.
  */
 import { createTwoFilesPatch } from "diff";
+import { isKnownToolCall } from "./types.js";
 const MAX_LINES = 200;
 const MAX_STATUS_LEN = 60;
 /**
@@ -24,83 +25,86 @@ 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 patch = createTwoFilesPatch(`a/${tool.path}`, `b/${tool.path}`, tool.before, tool.after, "", "", { context: 3 });
+            const lines = patch.split("\n");
+            const start = lines.findIndex((l) => l.startsWith("---"));
+            const diffLines = start >= 0 ? lines.slice(start) : lines;
+            return `${tool.path}\n\`\`\`diff\n${truncateLines(diffLines, 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 +149,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 +180,4 @@ 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}?`;
-    }
-}
 //# sourceMappingURL=format.js.map

package/dist/index.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
+import { execFileSync } from "node:child_process";
 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, engineCommand } 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
@@ -42,7 +42,8 @@ async function runDaemon() {
         });
     };
     const channel = createChannel(config.channel, (userId) => config.isAuthorized(userId), onUnauthorizedDM);
-    await new Orchestrator({ channel, engine: new ClaudeCodeEngine(), config }).start();
+    const enginePaths = Object.fromEntries(Object.entries(config.engines).map(([name, entry]) => [name, entry.path]));
+    await new Orchestrator({ channel, engines: createEngineMap(enginePaths), config }).start();
 }
 async function runApprove(args) {
     const code = args[0];
@@ -56,7 +57,7 @@ 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);
     console.log(`Approved ${pairing.userName} (${pairing.userId})`);
 }
 const SETUP_TIMEOUT_MS = 5 * 60 * 1000;
@@ -87,8 +88,36 @@ async function runSetup() {
                 throw new Error("Bot token required.");
             channelConfig = { type: "telegram", botToken };
         }
+        let engineName;
+        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;
+            }
+            const cmd = engineCommand(engineName);
+            if (cmd) {
+                try {
+                    execFileSync("which", [cmd], { stdio: "ignore" });
+                }
+                catch {
+                    console.log(`  "${cmd}" not found on PATH. Install it first or choose another engine.`);
+                    continue;
+                }
+            }
+            break;
+        }
+        // Resolve executable path for the chosen engine
+        const cmd = engineCommand(engineName);
+        const resolvedPath = cmd
+            ? execFileSync("which", [cmd], { encoding: "utf-8" }).trim()
+            : engineName; // SDK-based engines don't have a standalone binary
         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();
         let resolveFirstDM;
@@ -118,7 +147,7 @@ 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);
         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");

package/dist/orchestrator.d.ts

@@ -2,17 +2,18 @@ import type { Config } from "./config.js";
 import type { Channel, Engine } 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;
     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. */
@@ -27,6 +28,4 @@ export declare class Orchestrator {
     private buildMcpTools;
     private handlePermission;
     private updateStatusMessage;
-    /** Read default workspace CLAUDE.md to append to non-default workspace sessions. */
-    private readDefaultPrompt;
 }