@synergenius/flow-weaver-pack-weaver 0.9.57 → 0.9.59

package/src/ui/bot-workspace.tsx

@@ -28,7 +28,7 @@ import { SessionBar } from './session-bar';
 import { SettingsSection } from './settings-section';
 import { QueueInput } from './queue-input';
 import { GenesisBlock } from './genesis-block';
-import { ApprovalCard } from './approval-card';
+// ApprovalCard no longer needed — TaskBlock handles approval UI natively
 import { useStreamTimeline } from './use-stream-timeline';
 import { traceToTimeline } from './trace-to-timeline';
 import { sendSteerCommand } from './steer-api';
@@ -313,10 +313,43 @@ function BotWorkspace() {
     return text;
   }
 
-  // Approval slot for running TaskBlock
-  const approvalSlot = awaitingApproval && plan
-    ? React.createElement(ApprovalCard, { plan, callTool })
-    : null;
+  // Approval state for running TaskBlock
+  const [approvalStatus, setApprovalStatus] = useState<'pending' | 'approved' | 'rejected' | null>(null);
+  const [approvalLoading, setApprovalLoading] = useState(false);
+
+  // Sync approval status with stream events
+  useEffect(() => {
+    if (awaitingApproval) setApprovalStatus('pending');
+  }, [awaitingApproval]);
+
+  // Reset approval when stream restarts (new run)
+  useEffect(() => {
+    if (stream.events.length === 0) setApprovalStatus(null);
+  }, [stream.events.length]);
+
+  const handleApprove = useCallback(async () => {
+    setApprovalLoading(true);
+    try {
+      await callTool('fw_weaver_approve', { approved: true });
+      setApprovalStatus('approved');
+      toast('Plan approved', { type: 'success' });
+    } catch (err: unknown) {
+      toast(err instanceof Error ? err.message : 'Failed to approve', { type: 'error' });
+    }
+    setApprovalLoading(false);
+  }, [callTool]);
+
+  const handleReject = useCallback(async () => {
+    setApprovalLoading(true);
+    try {
+      await callTool('fw_weaver_approve', { approved: false });
+      setApprovalStatus('rejected');
+      toast('Plan rejected', { type: 'info' });
+    } catch (err: unknown) {
+      toast(err instanceof Error ? err.message : 'Failed to reject', { type: 'error' });
+    }
+    setApprovalLoading(false);
+  }, [callTool]);
 
   return React.createElement(Flex, {
     variant: 'column-stretch-start-nowrap-0',
@@ -376,7 +409,10 @@ function BotWorkspace() {
             cost,
             plan,
             error: stream.error,
-            approvalSlot,
+            approval: approvalStatus ?? undefined,
+            approvalLoading,
+            onApprove: handleApprove,
+            onReject: handleReject,
             onPause: handlePause,
             onStop: handleStop,
             pauseLoading: pausing,

package/src/ui/chat-bot-result.tsx

@@ -0,0 +1,81 @@
+/**
+ * Chat Bot Result — compact inline card for the AI chat thread.
+ *
+ * Renders when `fw_weaver_bot` returns a result. Shows task instruction,
+ * live status (polls fw_weaver_status), and an "Open" button to launch
+ * the full workspace.
+ */
+const React = require('react');
+const { useState, useEffect, useCallback } = React;
+const { Flex, Typography, StatusIcon, Button, toast } = require('@fw/plugin-ui-kit');
+
+interface ChatBotResultProps {
+  result: unknown;
+  toolName: string;
+  args: Record<string, unknown>;
+  callTool: (tool: string, args?: Record<string, unknown>) => Promise<unknown>;
+  openWorkspace: (data: Record<string, unknown>) => void;
+}
+
+function ChatBotResult({ result, args, callTool, openWorkspace }: ChatBotResultProps) {
+  const [status, setStatus] = useState<'running' | 'completed' | 'failed'>('running');
+  const [summary, setSummary] = useState<string | null>(null);
+
+  const parsed = typeof result === 'string' ? JSON.parse(result) : result;
+  const runId = parsed?.runId;
+  const instruction = parsed?.instruction || (args?.task as string) || 'Bot task';
+
+  // Poll status briefly
+  useEffect(() => {
+    if (!runId || status !== 'running') return;
+    const poll = async () => {
+      try {
+        const s = await callTool('fw_weaver_status') as Record<string, unknown>;
+        if (s?.currentRunId !== runId) {
+          // Run finished — check history
+          const history = await callTool('fw_weaver_history', { id: runId }) as unknown[];
+          if (Array.isArray(history) && history.length > 0) {
+            const run = history[0] as Record<string, unknown>;
+            setStatus(run.success ? 'completed' : 'failed');
+            setSummary(run.summary as string || null);
+          } else {
+            setStatus('completed');
+          }
+        }
+      } catch { /* non-fatal */ }
+    };
+    const interval = setInterval(poll, 3000);
+    poll();
+    return () => clearInterval(interval);
+  }, [runId, status, callTool]);
+
+  return React.createElement(Flex, {
+    variant: 'row-center-start-nowrap-10',
+    style: {
+      padding: '8px 12px',
+      borderRadius: 'var(--border-radius-regular)',
+      border: '1px solid var(--color-border-default)',
+      backgroundColor: 'var(--color-surface-low)',
+    },
+  },
+    React.createElement(StatusIcon, {
+      status: status === 'running' ? 'running' : status === 'completed' ? 'completed' : 'failed',
+      size: 'sm',
+    }),
+    React.createElement(Flex, { variant: 'column-start-start-nowrap-2', style: { flex: 1, minWidth: 0 } },
+      React.createElement(Typography, {
+        variant: 'caption-thick', color: 'color-text-high',
+        style: { overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' },
+      }, instruction),
+      summary && React.createElement(Typography, {
+        variant: 'smallCaption-regular', color: 'color-text-medium',
+      }, summary),
+    ),
+    React.createElement(Button, {
+      size: 'xs', variant: 'clear', color: 'secondary',
+      onClick: () => openWorkspace({ runId, packId: '@synergenius/flow-weaver-pack-weaver', live: status === 'running' }),
+    }, 'Open'),
+  );
+}
+
+module.exports = ChatBotResult;