clearclaw 0.7.0 → 0.9.0

package/dist/index.js

@@ -1,9 +1,8 @@
 #!/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 { createEngineMap, ENGINE_NAMES, engineCommand } from "./engine/registry.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";
@@ -41,9 +40,8 @@ async function runDaemon() {
             log.warn({ err }, "[pairing] failed to send pairing message");
         });
     };
-    const channel = createChannel(config.channel, (userId) => config.isAuthorized(userId), onUnauthorizedDM);
-    const enginePaths = Object.fromEntries(Object.entries(config.engines).map(([name, entry]) => [name, entry.path]));
-    await new Orchestrator({ channel, engines: createEngineMap(enginePaths), 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];
@@ -58,6 +56,8 @@ async function runApprove(args) {
         process.exit(1);
     }
     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;
@@ -89,6 +89,7 @@ async function runSetup() {
             channelConfig = { type: "telegram", botToken };
         }
         let engineName;
+        let resolvedPath;
         const engineList = ENGINE_NAMES.join("/");
         while (true) {
             engineName = (await ask(`Default engine [${engineList}]: `)).trim().toLowerCase();
@@ -96,23 +97,14 @@ async function runSetup() {
                 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;
-                }
+            try {
+                resolvedPath = resolveEnginePath(engineName);
+                break;
+            }
+            catch (err) {
+                console.log(`  ${err.message}`);
             }
-            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([
@@ -120,11 +112,12 @@ async function runSetup() {
         ]);
         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");
@@ -148,6 +141,8 @@ async function runSetup() {
             return;
         }
         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");
@@ -158,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,31 +1,65 @@
 import type { Config } from "./config.js";
-import type { Channel, Engine } from "./types.js";
+import type { Attachment, Channel, Engine, InboundMessage, MessageOrigin } from "./types.js";
 export interface OrchestratorOpts {
     channel: Channel;
     engines: Map<string, Engine>;
     config: Config;
+    transcribe?: (att: Attachment) => Promise<string>;
 }
 export declare class Orchestrator {
     private channel;
     private engines;
     private config;
     private chats;
-    private tasks;
+    private creatingWorkspaces;
+    private scheduler;
+    private planUsage;
+    private transcribe;
     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;
+    /**
+     * Turn audio attachments into message text. Engines can't consume audio, so it never
+     * reaches them; the echo lets the user catch a bad transcription before the agent acts.
+     */
+    private transcribeVoice;
     private routeMessage;
     private routeEngineEvent;
+    private routeTextChunk;
+    private publishTextSegment;
+    private flushTextSegment;
     private buildMcpTools;
     private handlePermission;
     private updateStatusMessage;
 }
+export declare function buildPrompt(messages: InboundMessage[]): string;