@whimmy-ai/whimmy 0.2.1 → 0.4.0

package/index.ts

@@ -1,5 +1,5 @@
 import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
-import { whimmyPlugin, registerWhimmyHooks } from './src/channel';
+import { whimmyPlugin, registerWhimmyHooks, setApprovalManager, broadcastApprovalRequest } from './src/channel';
 import { setWhimmyRuntime } from './src/runtime';
 import { registerWhimmyCli } from './src/setup';
 
@@ -13,6 +13,18 @@ const plugin = {
     api.registerChannel({ plugin: whimmyPlugin });
     registerWhimmyCli(api);
     registerWhimmyHooks(api);
+
+    // Register a gateway method that captures the ExecApprovalManager reference.
+    // The manager is only accessible via GatewayRequestHandlerOptions.context,
+    // so we use this method as the capture point.
+    // The backend should call this method once after connecting to the gateway.
+    api.registerGatewayMethod('whimmy.approval.init', (opts) => {
+      const manager = opts.context.execApprovalManager;
+      if (manager) {
+        setApprovalManager(manager);
+      }
+      opts.respond(true, { ok: true });
+    });
   },
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whimmy-ai/whimmy",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Whimmy channel plugin for OpenClaw",
   "main": "index.ts",
   "type": "module",

package/src/channel.ts

@@ -2,7 +2,8 @@ import WebSocket from 'ws';
 import { randomUUID } from 'node:crypto';
 import type { OpenClawConfig, OpenClawPluginApi } from 'openclaw/plugin-sdk';
 import { getWhimmyRuntime } from './runtime';
-import { resolveConnection, resolveConnectionAsync, buildWsUrl, isConfigured as isConfiguredUtil } from './utils';
+import { resolveConnection, resolveConnectionAsync, buildWsUrl, isConfigured as isConfiguredUtil, uploadFile } from './utils';
+import { ensureWhimmyAgent } from './sync';
 import type {
   WhimmyConfig,
   WhimmyChannelPlugin,
@@ -31,6 +32,27 @@ import type {
   AgentInfo,
 } from './types';
 
+// ============ Exec Approval Manager Singleton ============
+
+/**
+ * Minimal interface matching ExecApprovalManager.resolve().
+ * The full class isn't exported from openclaw/plugin-sdk's barrel,
+ * so we type just the method we need.
+ */
+interface ApprovalManagerLike {
+  resolve(recordId: string, decision: 'allow-once' | 'allow-always' | 'deny', resolvedBy?: string | null): boolean;
+}
+
+let approvalManager: ApprovalManagerLike | null = null;
+
+export function setApprovalManager(manager: ApprovalManagerLike): void {
+  approvalManager = manager;
+}
+
+export function getApprovalManager(): ApprovalManagerLike | null {
+  return approvalManager;
+}
+
 // ============ Config Helpers ============
 
 function getConfig(cfg: OpenClawConfig, accountId?: string): WhimmyConfig {
@@ -105,15 +127,14 @@ async function handleHookAgent(
 
   log?.info?.(`[Whimmy] Inbound: agent=${request.agentId} session=${request.sessionKey} text="${request.message.slice(0, 80)}..."`);
 
-  // Route to the correct OpenClaw agent.
-  const route = rt.channel.routing.resolveAgentRoute({
-    cfg,
-    channel: 'whimmy',
-    accountId,
-    peer: { kind: 'direct', id: request.sessionKey },
-  });
+  // Sync Whimmy agent config into OpenClaw (model + system prompt).
+  const syncedCfg = await ensureWhimmyAgent(request.agentId, request.agentConfig, log);
 
-  const storePath = rt.channel.session.resolveStorePath(cfg.session?.store, { agentId: route.agentId });
+  // Construct session key directly — no need for resolveAgentRoute.
+  const agentId = request.agentId;
+  const sessionKey = `agent:${agentId}:direct:${request.sessionKey}`.toLowerCase();
+  const mainSessionKey = `agent:${agentId}:main`.toLowerCase();
+  const storePath = rt.channel.session.resolveStorePath(syncedCfg.session?.store, { agentId });
 
   // Build media fields from attachments (following MS Teams / BlueBubbles pattern).
   const attachments = request.attachments ?? [];
@@ -138,7 +159,7 @@ async function handleHookAgent(
     CommandBody: request.message,
     From: request.sessionKey,
     To: request.sessionKey,
-    SessionKey: request.sessionKey,
+    SessionKey: sessionKey,
     AccountId: accountId,
     ChatType: 'direct',
     ConversationLabel: `Whimmy ${request.agentId}`,
@@ -164,10 +185,10 @@ async function handleHookAgent(
   // Record session.
   await rt.channel.session.recordInboundSession({
     storePath,
-    sessionKey: ctx.SessionKey || route.sessionKey,
+    sessionKey: ctx.SessionKey || sessionKey,
     ctx,
     updateLastRoute: {
-      sessionKey: route.mainSessionKey,
+      sessionKey: mainSessionKey,
       channel: 'whimmy',
       to: request.sessionKey,
       accountId,
@@ -195,13 +216,27 @@ async function handleHookAgent(
         deliver: async (payload: any) => {
           // Handle media attachments.
           const urls: string[] = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
-          for (const url of urls) {
-            const fileName = url.split('/').pop()?.split('?')[0] || 'file';
+          const connInfo = activeConnections.get(accountId)?.conn;
+          for (let url of urls) {
+            let fileName = url.split('/').pop()?.split('?')[0] || 'file';
+            let mimeType = payload.mimeType || 'application/octet-stream';
+            // Upload local files to the backend first.
+            if (connInfo && url.startsWith('/')) {
+              try {
+                const uploaded = await uploadFile(url, connInfo);
+                url = uploaded.url;
+                fileName = uploaded.fileName;
+                mimeType = uploaded.mimeType;
+              } catch (err: any) {
+                log?.error?.(`[Whimmy] Failed to upload file ${url}: ${err.message}`);
+                continue;
+              }
+            }
             const media: ChatMediaPayload = {
               sessionKey: request.sessionKey,
               agentId: request.agentId,
               mediaUrl: url,
-              mimeType: payload.mimeType || 'application/octet-stream',
+              mimeType,
               fileName,
               audioAsVoice: payload.audioAsVoice ?? false,
             };
@@ -215,7 +250,7 @@ async function handleHookAgent(
 
     await rt.channel.reply.dispatchReplyFromConfig({
       ctx,
-      cfg,
+      cfg: syncedCfg,
       dispatcher,
       replyOptions: {
         ...replyOptions,
@@ -264,14 +299,22 @@ async function handleHookApproval(
   request: HookApprovalRequest,
   log?: Logger,
 ): Promise<void> {
-  const rt = getWhimmyRuntime();
-
   log?.info?.(`[Whimmy] Approval: execution=${request.executionId} approved=${request.approved}`);
 
-  // TODO: Route approval resolution back into OpenClaw's execution engine.
-  // This depends on how OpenClaw exposes approval resolution to channel plugins.
-  // For now, log it — the exact API will depend on the OpenClaw SDK version.
-  log?.debug?.(`[Whimmy] Approval resolution for ${request.executionId}: approved=${request.approved}, reason=${request.reason}`);
+  const manager = getApprovalManager();
+  if (!manager) {
+    log?.warn?.(`[Whimmy] ExecApprovalManager not yet captured — cannot resolve execution ${request.executionId}`);
+    return;
+  }
+
+  const decision = request.approved ? 'allow-once' as const : 'deny' as const;
+  const resolved = manager.resolve(request.executionId, decision, 'whimmy');
+
+  if (resolved) {
+    log?.info?.(`[Whimmy] Resolved execution ${request.executionId} → ${decision}`);
+  } else {
+    log?.warn?.(`[Whimmy] Failed to resolve execution ${request.executionId} (expired or unknown)`);
+  }
 }
 
 // ============ Inbound Event Handlers ============
@@ -300,6 +343,11 @@ function broadcastEvent(event: string, payload: unknown): void {
   }
 }
 
+/** Forward an exec.approval.requested event to all connected Whimmy backends. */
+export function broadcastApprovalRequest(payload: ExecApprovalRequestedPayload): void {
+  broadcastEvent('exec.approval.requested', payload);
+}
+
 // ============ Actions ============
 
 function createWhimmyActions(ws: WebSocket, sessionKey: string, agentId: string) {
@@ -323,7 +371,7 @@ function createWhimmyActions(ws: WebSocket, sessionKey: string, agentId: string)
 
 // Track active connections per account to prevent duplicate connections
 // when the framework retries startAccount.
-const activeConnections = new Map<string, { ws: WebSocket; stopFn: () => void }>();
+const activeConnections = new Map<string, { ws: WebSocket; conn: ConnectionInfo; stopFn: () => void }>();
 
 async function connectWebSocket(
   conn: ConnectionInfo,
@@ -470,7 +518,7 @@ async function connectWebSocket(
     log?.info?.(`[Whimmy][${accountId}] Stopped`);
   };
 
-  const result = { ws, stopFn };
+  const result = { ws, conn, stopFn };
   activeConnections.set(accountId, result);
   return result;
 }
@@ -565,6 +613,18 @@ export const whimmyPlugin: WhimmyChannelPlugin = {
       const actions = createWhimmyActions(conn.ws, sessionKey, agentId);
 
       switch (action) {
+        case 'send': {
+          const text = typeof params.text === 'string' ? params.text : '';
+          if (!text) return { ok: false, error: 'Missing text' };
+          const chunk: ChatChunkPayload = {
+            sessionKey,
+            agentId,
+            content: text,
+            done: true,
+          };
+          sendEvent(conn.ws, 'chat.done', chunk);
+          return { ok: true };
+        }
         case 'react': {
           const messageId = typeof params.messageId === 'string' ? params.messageId : '';
           const emoji = typeof params.emoji === 'string' ? params.emoji : '';
@@ -586,18 +646,46 @@ export const whimmyPlugin: WhimmyChannelPlugin = {
           return { ok: true };
         }
         case 'sendAttachment': {
-          const mediaUrl = typeof params.mediaUrl === 'string' ? params.mediaUrl : '';
-          if (!mediaUrl) return { ok: false, error: 'Missing mediaUrl' };
-          const fileName = typeof params.fileName === 'string' ? params.fileName : mediaUrl.split('/').pop()?.split('?')[0] || 'file';
+          let mediaUrl = typeof params.mediaUrl === 'string' ? params.mediaUrl : '';
+          let fileName = typeof params.fileName === 'string' ? params.fileName : '';
+          let mimeType = typeof params.mimeType === 'string' ? params.mimeType : '';
+          const filePath = typeof params.filePath === 'string' ? params.filePath : '';
+
+          // If a local file path is provided, upload it to the backend first.
+          if (filePath && !mediaUrl) {
+            try {
+              const uploaded = await uploadFile(filePath, conn.conn);
+              mediaUrl = uploaded.url;
+              if (!fileName) fileName = uploaded.fileName;
+              if (!mimeType) mimeType = uploaded.mimeType;
+            } catch (uploadErr: any) {
+              return { ok: false, error: `File upload failed: ${uploadErr.message}` };
+            }
+          }
+
+          if (!mediaUrl) return { ok: false, error: 'Missing mediaUrl or filePath' };
+          if (!fileName) fileName = mediaUrl.split('/').pop()?.split('?')[0] || 'file';
+          if (!mimeType) mimeType = 'application/octet-stream';
+
           const media: ChatMediaPayload = {
             sessionKey,
             agentId,
             mediaUrl,
-            mimeType: typeof params.mimeType === 'string' ? params.mimeType : 'application/octet-stream',
+            mimeType,
             fileName,
             audioAsVoice: params.audioAsVoice === true,
           };
           sendEvent(conn.ws, 'chat.media', media);
+          // Send caption as a follow-up text message if provided.
+          if (typeof params.caption === 'string' && params.caption) {
+            const caption: ChatChunkPayload = {
+              sessionKey,
+              agentId,
+              content: params.caption,
+              done: true,
+            };
+            sendEvent(conn.ws, 'chat.done', caption);
+          }
           return { ok: true };
         }
         default:
@@ -614,9 +702,19 @@ export const whimmyPlugin: WhimmyChannelPlugin = {
       return { ok: true as const, to: to.trim() };
     },
     sendText: async ({ cfg, to, text, accountId, log }: any) => {
-      // Outbound from OpenClaw CLI → send as chat.done through the WS.
-      // This is handled by the gateway connection, not a standalone HTTP call.
-      // For now, log it. The gateway dispatchReply handles the normal flow.
+      const id = accountId ?? 'default';
+      const conn = activeConnections.get(id);
+      if (!conn || conn.ws.readyState !== WebSocket.OPEN) {
+        log?.warn?.(`[Whimmy] sendText: not connected (account=${id})`);
+        return { channel: 'whimmy', messageId: randomUUID() };
+      }
+      const chunk: ChatChunkPayload = {
+        sessionKey: to,
+        agentId: 'default',
+        content: text,
+        done: true,
+      };
+      sendEvent(conn.ws, 'chat.done', chunk);
       log?.debug?.(`[Whimmy] sendText: to=${to} text=${text.slice(0, 80)}`);
       return {
         channel: 'whimmy',

package/src/sync.ts

@@ -0,0 +1,86 @@
+import { createHash } from 'node:crypto';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import type { OpenClawConfig } from 'openclaw/plugin-sdk';
+import { getWhimmyRuntime } from './runtime';
+import type { AgentConfig, Logger } from './types';
+
+/** In-memory cache: agentId → hash of { model, systemPrompt }. */
+const hashCache = new Map<string, string>();
+
+function computeHash(agentConfig: AgentConfig): string {
+  const data = JSON.stringify({
+    model: agentConfig.model,
+    systemPrompt: agentConfig.systemPrompt ?? '',
+  });
+  return createHash('sha256').update(data).digest('hex');
+}
+
+/**
+ * Ensure the Whimmy agent exists in OpenClaw's config with the correct
+ * model and system prompt.  Uses an in-memory hash cache to skip redundant
+ * disk writes when nothing changed.
+ */
+export async function ensureWhimmyAgent(
+  agentId: string,
+  agentConfig: AgentConfig,
+  log?: Logger,
+): Promise<OpenClawConfig> {
+  const rt = getWhimmyRuntime();
+  const hash = computeHash(agentConfig);
+
+  // Fast path: nothing changed since last sync.
+  if (hashCache.get(agentId) === hash) {
+    log?.debug?.(`[Whimmy] Agent config unchanged for ${agentId}, skipping sync`);
+    return rt.config.loadConfig();
+  }
+
+  log?.info?.(`[Whimmy] Syncing agent config for ${agentId}`);
+
+  const cfg = rt.config.loadConfig();
+
+  // Ensure agents.list exists.
+  if (!cfg.agents) {
+    (cfg as any).agents = {};
+  }
+  if (!cfg.agents!.list) {
+    cfg.agents!.list = [];
+  }
+
+  // Find or create agent entry.
+  let entry = cfg.agents!.list!.find((a) => a.id === agentId);
+  if (!entry) {
+    cfg.agents!.list!.push({ id: agentId });
+    entry = cfg.agents!.list![cfg.agents!.list!.length - 1];
+  }
+
+  // Set model.
+  entry!.model = agentConfig.model;
+
+  // Resolve workspace dir and write SOUL.md.
+  const workspace = cfg.agents?.defaults?.workspace
+    ?? join(homedir(), '.openclaw', 'workspace');
+  const agentDir = join(workspace, 'agents', agentId);
+
+  mkdirSync(agentDir, { recursive: true });
+
+  // Write SOUL.md with the system prompt (or empty to clear a previous one).
+  writeFileSync(join(agentDir, 'SOUL.md'), agentConfig.systemPrompt ?? '', 'utf-8');
+
+  // Write an empty BOOTSTRAP.md so the default workspace bootstrap isn't inherited.
+  writeFileSync(join(agentDir, 'BOOTSTRAP.md'), '', 'utf-8');
+
+  entry!.workspace = agentDir;
+  entry!.agentDir = agentDir;
+
+  // Persist config.
+  await rt.config.writeConfigFile(cfg);
+
+  // Update cache.
+  hashCache.set(agentId, hash);
+
+  log?.info?.(`[Whimmy] Agent ${agentId} synced: model=${agentConfig.model} agentDir=${agentDir}`);
+
+  return cfg;
+}

package/src/utils.ts

@@ -1,3 +1,5 @@
+import { readFileSync } from 'node:fs';
+import { basename } from 'node:path';
 import type { ConnectionInfo, WhimmyConfig, Logger } from './types';
 
 const DEFAULT_HOST = 'api.whimmy.ai';
@@ -176,3 +178,45 @@ export async function retryWithBackoff<T>(
 
   throw new Error('Retry exhausted');
 }
+
+/**
+ * Upload a local file to the Whimmy backend.
+ * Returns the uploaded file's public URL.
+ */
+export async function uploadFile(
+  filePath: string,
+  conn: ConnectionInfo,
+): Promise<{ url: string; fileName: string; mimeType: string }> {
+  const protocol = conn.tls ? 'https' : 'http';
+  const url = `${protocol}://${conn.host}/files/upload`;
+
+  const fileBuffer = readFileSync(filePath);
+  const fileName = basename(filePath);
+
+  const form = new FormData();
+  form.append('file', new Blob([fileBuffer]), fileName);
+
+  const resp = await fetch(url, {
+    method: 'POST',
+    headers: { 'Authorization': `Bearer ${conn.token}` },
+    body: form,
+  });
+
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`File upload failed (${resp.status}): ${body}`);
+  }
+
+  const data = await resp.json() as {
+    id: string;
+    url: string;
+    originalName: string;
+    mimeType: string;
+  };
+
+  return {
+    url: data.url,
+    fileName: data.originalName,
+    mimeType: data.mimeType,
+  };
+}