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

package/src/ai-chat-provider.ts

@@ -24,6 +24,7 @@ import { runRegistry } from './bot/run-registry.js';
 import { ProjectModelStore } from './bot/project-model.js';
 import { InsightEngine } from './bot/insight-engine.js';
 import { buildSystemPrompt } from './bot/system-prompt.js';
+import { BotRegistry } from './bot/bot-registry.js';
 
 /** Throttle orphan recovery to max once per 30s. */
 let lastOrphanRecoveryTime = 0;
@@ -121,9 +122,24 @@ const toolHandlers: Record<
   },
 
   async fw_weaver_bot(args, ctx) {
-
-
-
+    // Resolve bot from registry if botId is provided
+    const botId = args.botId as string | undefined;
+    let registryWorkflowFile: string | undefined;
+
+    if (botId) {
+      const registry = new BotRegistry(ctx.workspacePath);
+      const bot = registry.get(botId);
+      if (!bot) {
+        return JSON.stringify({ error: `Bot '${botId}' not found` });
+      }
+      const validation = registry.validate(botId);
+      if (!validation.valid) {
+        return JSON.stringify({ error: `Bot '${botId}' is invalid: ${validation.error}` });
+      }
+      registryWorkflowFile = path.isAbsolute(bot.filePath)
+        ? bot.filePath
+        : path.join(ctx.workspacePath, bot.filePath);
+    }
 
 
     const task = {
@@ -137,9 +153,14 @@ const toolHandlers: Record<
       },
     };
     const packRoot = new URL('..', import.meta.url);
-    let workflowPath = fileURLToPath(new URL('src/workflows/weaver-bot.ts', packRoot));
-    if (!fs.existsSync(workflowPath)) {
-      workflowPath = fileURLToPath(new URL('dist/workflows/weaver-bot.js', packRoot));
+    let workflowPath: string;
+    if (registryWorkflowFile) {
+      workflowPath = registryWorkflowFile;
+    } else {
+      workflowPath = fileURLToPath(new URL('src/workflows/weaver-bot.ts', packRoot));
+      if (!fs.existsSync(workflowPath)) {
+        workflowPath = fileURLToPath(new URL('dist/workflows/weaver-bot.js', packRoot));
+      }
     }
 
     const projectDir = ctx.workspacePath || process.cwd();
@@ -551,6 +572,57 @@ const toolHandlers: Record<
       },
     }, null, 2);
   },
+
+  async fw_weaver_list_bots(args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const registry = new BotRegistry(ctx.workspacePath);
+    const bots = registry.list();
+    const withValidation = bots.map((bot) => ({
+      ...bot,
+      validation: registry.validate(bot.id),
+    }));
+    return JSON.stringify(withValidation, null, 2);
+  },
+
+  async fw_weaver_register_bot(args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const registry = new BotRegistry(ctx.workspacePath);
+    const bot = {
+      id: (args.id as string) || `bot-${Date.now().toString(36)}`,
+      name: args.name as string,
+      description: (args.description as string) || '',
+      icon: args.icon as string | undefined,
+      color: args.color as string | undefined,
+      filePath: args.filePath as string,
+      workflowExport: args.workflowExport as string,
+      paramName: (args.paramName as string) || 'taskJson',
+      packId: args.packId as string | undefined,
+      ejected: args.ejected as boolean | undefined,
+      sourceTemplateId: args.sourceTemplateId as string | undefined,
+    };
+    registry.register(bot);
+    return JSON.stringify({ registered: true, bot });
+  },
+
+  async fw_weaver_unregister_bot(args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const registry = new BotRegistry(ctx.workspacePath);
+    const id = args.id as string;
+    const removed = registry.unregister(id);
+    return JSON.stringify({ removed, id });
+  },
+
+  async fw_weaver_validate_bot(args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const registry = new BotRegistry(ctx.workspacePath);
+    const id = args.id as string;
+    const result = registry.validate(id);
+    return JSON.stringify(result);
+  },
+
+  async fw_weaver_eject_bot(args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const registry = new BotRegistry(ctx.workspacePath);
+    const id = args.id as string;
+    const newFilePath = args.filePath as string;
+    const ejected = registry.eject(id, newFilePath);
+    return JSON.stringify({ ejected, id, filePath: newFilePath });
+  },
 };
 
 // ---------------------------------------------------------------------------
@@ -602,7 +674,7 @@ export default {
       title: 'Weaver Capabilities',
       content: `Beyond standard Flow Weaver tools, you also have:
 
-- \`fw_weaver_bot\`: Autonomous workflow creation/modification from natural language tasks
+- \`fw_weaver_bot\`: Autonomous workflow creation/modification from natural language tasks (supports \`botId\` to run registered bots)
 - \`fw_weaver_steer\`: Control running bots (pause, resume, cancel, redirect)
 - \`fw_weaver_status\`: Current bot session state
 - \`fw_weaver_queue\`: Background task queue management
@@ -612,6 +684,11 @@ export default {
 - \`fw_weaver_history\`: Past workflow execution history
 - \`fw_weaver_providers\`: Available AI providers
 - \`fw_weaver_genesis\`: Self-evolution cycle for workflows
+- \`fw_weaver_list_bots\`: List all registered bots with validation status
+- \`fw_weaver_register_bot\`: Register a new bot workflow
+- \`fw_weaver_unregister_bot\`: Remove a bot registration
+- \`fw_weaver_validate_bot\`: Validate a bot's file and export
+- \`fw_weaver_eject_bot\`: Mark a bot as ejected with a new file path
 
 Proactively offer these when relevant.`,
       priority: 15,
@@ -663,6 +740,23 @@ Proactively offer these when relevant.`,
       }
     }
 
+    // Registered bots
+    if (context.workspacePath) {
+      try {
+        const registry = new BotRegistry(context.workspacePath);
+        const bots = registry.list();
+        if (bots.length > 0) {
+          const botLines = bots.map((b) => `- **${b.name}** (id: \`${b.id}\`): ${b.description}`).join('\n');
+          sections.push({
+            id: 'registered-bots',
+            title: 'Registered Bots',
+            content: `The user has registered bot workflows. To run a bot, use \`fw_weaver_bot\` with \`botId\` parameter.\n\n${botLines}`,
+            priority: 25,
+          });
+        }
+      } catch { /* non-fatal */ }
+    }
+
     return sections;
   },
 };

package/src/bot/bot-registry.ts

@@ -0,0 +1,116 @@
+/**
+ * Bot registry — manages .fw/bots.json in the user's workspace.
+ * Reads, writes, validates bot registrations.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+export interface BotRegistration {
+  id: string;
+  name: string;
+  description: string;
+  icon?: string;
+  color?: string;
+  filePath: string;
+  workflowExport: string;
+  paramName: string;
+  sourceTemplateId?: string;
+  packId?: string;
+  ejected?: boolean;
+}
+
+const BOTS_FILE = '.fw/bots.json';
+
+export class BotRegistry {
+  private _cache: BotRegistration[] | null = null;
+  private _cacheMtime: number = 0;
+
+  constructor(private readonly workspacePath: string) {}
+
+  private get botsPath(): string {
+    return path.join(this.workspacePath, BOTS_FILE);
+  }
+
+  list(): BotRegistration[] {
+    try {
+      const mtime = fs.statSync(this.botsPath).mtimeMs;
+      if (this._cache && mtime === this._cacheMtime) {
+        return this._cache;
+      }
+      const raw = fs.readFileSync(this.botsPath, 'utf-8');
+      const parsed = JSON.parse(raw);
+      const result = Array.isArray(parsed) ? parsed : [];
+      this._cache = result;
+      this._cacheMtime = mtime;
+      return result;
+    } catch {
+      return [];
+    }
+  }
+
+  get(id: string): BotRegistration | null {
+    return this.list().find((b) => b.id === id) ?? null;
+  }
+
+  register(bot: BotRegistration): void {
+    const bots = this.list();
+    const existing = bots.findIndex((b) => b.id === bot.id);
+    if (existing >= 0) {
+      bots[existing] = { ...bots[existing], ...bot };
+    } else {
+      bots.push(bot);
+    }
+    this.save(bots);
+  }
+
+  unregister(id: string): boolean {
+    const bots = this.list();
+    const filtered = bots.filter((b) => b.id !== id);
+    if (filtered.length === bots.length) return false;
+    this.save(filtered);
+    return true;
+  }
+
+  eject(id: string, newFilePath: string): boolean {
+    const bots = this.list();
+    const bot = bots.find((b) => b.id === id);
+    if (!bot) return false;
+    bot.filePath = newFilePath;
+    bot.ejected = true;
+    this.save(bots);
+    return true;
+  }
+
+  validate(id: string): { valid: boolean; fileExists: boolean; exportValid: boolean; error: string | null } {
+    const bot = this.get(id);
+    if (!bot) return { valid: false, fileExists: false, exportValid: false, error: 'Bot not found' };
+
+    const absPath = path.isAbsolute(bot.filePath)
+      ? bot.filePath
+      : path.join(this.workspacePath, bot.filePath);
+
+    if (!fs.existsSync(absPath)) {
+      return { valid: false, fileExists: false, exportValid: false, error: `File not found: ${bot.filePath}` };
+    }
+
+    // Check export exists by parsing the file
+    try {
+      const source = fs.readFileSync(absPath, 'utf-8');
+      const exportPattern = new RegExp(`export\\s+(?:(?:async\\s+)?function|const)\\s+${bot.workflowExport}\\b`);
+      if (!exportPattern.test(source)) {
+        return { valid: false, fileExists: true, exportValid: false, error: `Export '${bot.workflowExport}' not found in ${bot.filePath}` };
+      }
+    } catch (err) {
+      return { valid: false, fileExists: true, exportValid: false, error: `Cannot read file: ${(err as Error).message}` };
+    }
+
+    return { valid: true, fileExists: true, exportValid: true, error: null };
+  }
+
+  private save(bots: BotRegistration[]): void {
+    this._cache = null;
+    const dir = path.dirname(this.botsPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(this.botsPath, JSON.stringify(bots, null, 2) + '\n');
+  }
+}

package/src/bot/runner.ts

@@ -257,10 +257,13 @@ export async function runWorkflow(
     const nodeTypes = new Map<string, string>(); // nodeId → nodeTypeName
     const nodeOutputs = new Map<string, Array<{ portLabel: string; value: unknown }>>();
 
-    /** Truncate large string values; preserve objects as-is (UI handles overflow). */
-    function truncateValue(value: unknown, maxLen = 8192): unknown {
-      if (typeof value === 'string' && value.length > maxLen) {
-        return value.slice(0, maxLen) + '…';
+    /** Try to parse JSON strings into objects so the UI renders them as structured JSON. */
+    function resolveOutputValue(value: unknown): unknown {
+      if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+          try { return JSON.parse(value); } catch { /* not valid JSON, return as-is */ }
+        }
       }
       return value;
     }
@@ -286,7 +289,7 @@ export async function runWorkflow(
             if (nodeTypeName) nodeTypes.set(nodeId, nodeTypeName);
             const label = resolvePortLabel(nodeTypeName ?? nodeTypes.get(nodeId), portName);
             const outputs = nodeOutputs.get(nodeId) ?? [];
-            outputs.push({ portLabel: label, value: truncateValue(traceEvent.data.value) });
+            outputs.push({ portLabel: label, value: resolveOutputValue(traceEvent.data.value) });
             nodeOutputs.set(nodeId, outputs);
           }
         }

package/src/ui/bot-panel.tsx

@@ -0,0 +1,382 @@
+/**
+ * Weaver Bot Panel — sidebar component.
+ *
+ * Replaces BotPanel.tsx + BotLibrary.tsx from the platform's cloud-bot-panel.
+ * Runs in the pack sandbox — uses CommonJS require for platform deps,
+ * React.createElement throughout (no JSX transform in sandbox).
+ *
+ * Features:
+ * - Lists registered bots via fw_weaver_list_bots
+ * - Validation badges per bot
+ * - Register existing workflow form
+ * - Open workspace action per bot
+ * - Unregister action per bot
+ */
+const React = require('react');
+const { useState, useEffect, useCallback, useRef } = React;
+const {
+  Flex, Typography, Button, IconButton, Icon, Input, EmptyState,
+  ScrollArea, StatusIcon, toast, usePackWorkspace,
+} = require('@fw/plugin-ui-kit');
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface Bot {
+  id: string;
+  name: string;
+  description: string;
+  icon?: string;
+  color?: string;
+  filePath: string;
+  workflowExport: string;
+  paramName: string;
+  packId?: string;
+  ejected?: boolean;
+  validation?: {
+    state: 'valid' | 'invalid' | 'checking' | 'unknown';
+    fileExists?: boolean;
+    exportValid?: boolean;
+    errorMessage?: string;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function parseToolResult(raw: unknown): unknown {
+  if (typeof raw === 'string') {
+    try { return JSON.parse(raw); } catch { return raw; }
+  }
+  return raw;
+}
+
+function validationIcon(state: string | undefined): { icon: string; color: string } {
+  switch (state) {
+    case 'valid': return { icon: 'checkCircle', color: 'var(--color-success)' };
+    case 'invalid': return { icon: 'error', color: 'var(--color-danger)' };
+    case 'checking': return { icon: 'sync', color: 'var(--color-warning)' };
+    default: return { icon: 'helpOutline', color: 'var(--color-text-subtle)' };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Component
+// ---------------------------------------------------------------------------
+
+function BotPanel() {
+  const ctx = usePackWorkspace();
+  const { callTool, dispatchEvent } = ctx;
+  const packId = ctx.packId;
+
+  // Bot list state
+  const [bots, setBots] = useState<Bot[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  // Register form state
+  const [showRegForm, setShowRegForm] = useState(false);
+  const [regName, setRegName] = useState('');
+  const [regFilePath, setRegFilePath] = useState('');
+  const [regExport, setRegExport] = useState('');
+  const [registering, setRegistering] = useState(false);
+
+  // Unregister confirmation
+  const [confirmUnregId, setConfirmUnregId] = useState<string | null>(null);
+  const [unregistering, setUnregistering] = useState(false);
+
+  // ── Load bots ──────────────────────────────────────────────────
+  const loadBots = useCallback(async () => {
+    try {
+      setError(null);
+      const raw = await callTool('fw_weaver_list_bots');
+      const parsed = parseToolResult(raw);
+      if (Array.isArray(parsed)) {
+        setBots(parsed as Bot[]);
+      } else {
+        setBots([]);
+      }
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : 'Failed to load bots';
+      setError(msg);
+    } finally {
+      setLoading(false);
+    }
+  }, [callTool]);
+
+  // Load on mount
+  const mountedRef = useRef(false);
+  useEffect(() => {
+    if (!mountedRef.current) {
+      mountedRef.current = true;
+      loadBots();
+    }
+  }, [loadBots]);
+
+  // ── Register bot ───────────────────────────────────────────────
+  const handleRegister = useCallback(async () => {
+    if (!regName.trim() || !regFilePath.trim() || !regExport.trim()) return;
+    setRegistering(true);
+    try {
+      await callTool('fw_weaver_register_bot', {
+        name: regName.trim(),
+        filePath: regFilePath.trim(),
+        workflowExport: regExport.trim(),
+        paramName: 'taskJson',
+      });
+      toast('Bot registered', { type: 'success' });
+      setRegName('');
+      setRegFilePath('');
+      setRegExport('');
+      setShowRegForm(false);
+      await loadBots();
+    } catch (err: unknown) {
+      toast(err instanceof Error ? err.message : 'Registration failed', { type: 'error' });
+    } finally {
+      setRegistering(false);
+    }
+  }, [regName, regFilePath, regExport, callTool, loadBots]);
+
+  // ── Unregister bot ─────────────────────────────────────────────
+  const handleUnregister = useCallback(async (id: string) => {
+    setUnregistering(true);
+    try {
+      await callTool('fw_weaver_unregister_bot', { id });
+      toast('Bot unregistered', { type: 'warning' });
+      setConfirmUnregId(null);
+      await loadBots();
+    } catch (err: unknown) {
+      toast(err instanceof Error ? err.message : 'Unregister failed', { type: 'error' });
+    } finally {
+      setUnregistering(false);
+    }
+  }, [callTool, loadBots]);
+
+  // ── Open workspace ─────────────────────────────────────────────
+  const handleOpenWorkspace = useCallback((botId: string) => {
+    dispatchEvent('fw:open-bot-workspace', { botId, packId, live: false });
+  }, [dispatchEvent, packId]);
+
+  // ── Render ─────────────────────────────────────────────────────
+
+  const hasBots = bots.length > 0;
+
+  // Header row with title + actions
+  const header = React.createElement(Flex, {
+    variant: 'row-center-between-nowrap-8',
+    style: { padding: '8px 12px', borderBottom: '1px solid var(--color-border-default)', flexShrink: 0 },
+  },
+    React.createElement(Flex, { variant: 'row-center-start-nowrap-6' },
+      React.createElement(Icon, { name: 'smartToy', size: 16, color: 'color-text-medium' }),
+      React.createElement(Typography, { variant: 'caption-thick', color: 'color-text-high' }, 'Bots'),
+    ),
+    React.createElement(Flex, { variant: 'row-center-start-nowrap-4' },
+      React.createElement(IconButton, {
+        icon: 'refresh', size: 'xs', variant: 'clear',
+        onClick: loadBots, title: 'Refresh',
+      }),
+      React.createElement(IconButton, {
+        icon: 'add', size: 'xs', variant: 'clear',
+        onClick: () => setShowRegForm((v: boolean) => !v), title: 'Register bot',
+      }),
+    ),
+  );
+
+  // Registration form
+  const regForm = showRegForm ? React.createElement(Flex, {
+    variant: 'column-start-start-nowrap-8',
+    style: {
+      padding: '10px 12px',
+      borderBottom: '1px solid var(--color-border-default)',
+      backgroundColor: 'var(--color-surface-low)',
+    },
+  },
+    React.createElement(Typography, { variant: 'smallCaption-thick', color: 'color-text-medium' }, 'Register Existing Workflow'),
+    React.createElement(Input, {
+      type: 'text', size: 'small', placeholder: 'Bot name',
+      value: regName, onChange: setRegName,
+    }),
+    React.createElement(Input, {
+      type: 'text', size: 'small', placeholder: 'File path (e.g. my-bot.ts)',
+      value: regFilePath, onChange: setRegFilePath,
+    }),
+    React.createElement(Input, {
+      type: 'text', size: 'small', placeholder: 'Export name (e.g. myBot)',
+      value: regExport, onChange: setRegExport,
+    }),
+    React.createElement(Flex, { variant: 'row-center-start-nowrap-6' },
+      React.createElement(Button, {
+        size: 'xs', variant: 'fill', color: 'primary',
+        onClick: handleRegister,
+        disabled: registering || !regName.trim() || !regFilePath.trim() || !regExport.trim(),
+      }, registering ? 'Registering...' : 'Register'),
+      React.createElement(Button, {
+        size: 'xs', variant: 'clear', color: 'secondary',
+        onClick: () => { setShowRegForm(false); setRegName(''); setRegFilePath(''); setRegExport(''); },
+      }, 'Cancel'),
+    ),
+  ) : null;
+
+  // Loading state
+  if (loading) {
+    return React.createElement(Flex, {
+      variant: 'column-stretch-start-nowrap-0',
+      style: { width: '100%', height: '100%' },
+    },
+      header,
+      React.createElement(Flex, {
+        variant: 'column-center-center-nowrap-8',
+        style: { flex: 1, padding: '24px' },
+      },
+        React.createElement(Typography, { variant: 'caption-regular', color: 'color-text-subtle' }, 'Loading bots...'),
+      ),
+    );
+  }
+
+  // Error state
+  if (error) {
+    return React.createElement(Flex, {
+      variant: 'column-stretch-start-nowrap-0',
+      style: { width: '100%', height: '100%' },
+    },
+      header,
+      React.createElement(Flex, {
+        variant: 'column-center-center-nowrap-8',
+        style: { flex: 1, padding: '24px' },
+      },
+        React.createElement(Typography, { variant: 'caption-regular', color: 'color-danger' }, error),
+        React.createElement(Button, { size: 'xs', variant: 'outlined', onClick: loadBots }, 'Retry'),
+      ),
+    );
+  }
+
+  // Bot cards
+  const botCards = bots.map((bot: Bot) => {
+    const vState = bot.validation?.state;
+    const vInfo = validationIcon(vState);
+    const isConfirming = confirmUnregId === bot.id;
+
+    return React.createElement(Flex, {
+      key: bot.id,
+      variant: 'row-center-start-nowrap-8',
+      style: {
+        padding: '7px 8px',
+        borderRadius: 'var(--border-radius-secondary)',
+        border: '1px solid var(--color-border-default)',
+        cursor: 'pointer',
+        transition: 'background-color 0.12s',
+      },
+      onClick: () => handleOpenWorkspace(bot.id),
+      onMouseEnter: (e: React.MouseEvent) => {
+        (e.currentTarget as HTMLElement).style.backgroundColor = 'var(--color-surface-raised)';
+      },
+      onMouseLeave: (e: React.MouseEvent) => {
+        (e.currentTarget as HTMLElement).style.backgroundColor = '';
+      },
+    },
+      // Icon
+      React.createElement('div', {
+        style: {
+          width: '26px', height: '26px',
+          borderRadius: 'var(--border-radius-compact)',
+          display: 'flex', alignItems: 'center', justifyContent: 'center', flexShrink: 0,
+          background: bot.color
+            ? `color-mix(in srgb, ${bot.color} 14%, transparent)`
+            : 'var(--color-surface-low)',
+        },
+      },
+        React.createElement(Icon, {
+          name: bot.icon || 'smartToy', size: 14,
+          color: bot.color ? undefined : 'color-text-medium',
+          style: bot.color ? { color: bot.color } : undefined,
+        }),
+      ),
+
+      // Name + description
+      React.createElement(Flex, {
+        variant: 'column-start-start-nowrap-1',
+        style: { flex: 1, minWidth: 0 },
+      },
+        React.createElement(Flex, { variant: 'row-center-start-nowrap-4' },
+          React.createElement(Typography, {
+            variant: 'caption-thick', color: 'color-text-high',
+            style: { overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' },
+          }, bot.name),
+          // Validation badge
+          React.createElement(Icon, {
+            name: vInfo.icon, size: 12,
+            style: { color: vInfo.color, flexShrink: 0 },
+          }),
+        ),
+        bot.description ? React.createElement(Typography, {
+          variant: 'smallCaption-regular', color: 'color-text-medium',
+          style: { overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' },
+        }, bot.description) : null,
+      ),
+
+      // Actions
+      isConfirming
+        ? React.createElement(Flex, {
+            variant: 'row-center-start-nowrap-4',
+            onClick: (e: React.MouseEvent) => e.stopPropagation(),
+          },
+            React.createElement(Button, {
+              size: 'xs', variant: 'fill', color: 'danger',
+              onClick: () => handleUnregister(bot.id),
+              disabled: unregistering,
+            }, unregistering ? '...' : 'Yes'),
+            React.createElement(Button, {
+              size: 'xs', variant: 'clear', color: 'secondary',
+              onClick: () => setConfirmUnregId(null),
+            }, 'No'),
+          )
+        : React.createElement(Flex, {
+            variant: 'row-center-start-nowrap-2',
+            onClick: (e: React.MouseEvent) => e.stopPropagation(),
+          },
+            React.createElement(IconButton, {
+              icon: 'openInNew', size: 'xs', variant: 'clear',
+              onClick: () => handleOpenWorkspace(bot.id),
+              title: 'Open workspace',
+            }),
+            React.createElement(IconButton, {
+              icon: 'close', size: 'xs', variant: 'clear',
+              onClick: () => setConfirmUnregId(bot.id),
+              title: 'Unregister',
+            }),
+          ),
+    );
+  });
+
+  // Main content
+  const content = hasBots
+    ? React.createElement(ScrollArea, { style: { flex: 1 } },
+        React.createElement(Flex, {
+          variant: 'column-start-start-nowrap-4',
+          style: { padding: '8px 12px' },
+        }, ...botCards),
+      )
+    : React.createElement(Flex, {
+        variant: 'column-center-center-nowrap-0',
+        style: { flex: 1, padding: '24px' },
+      },
+        React.createElement(EmptyState, {
+          icon: 'smartToy',
+          message: 'No bots registered',
+          description: 'Register an existing workflow or ask the AI assistant to create one.',
+        }),
+      );
+
+  return React.createElement(Flex, {
+    variant: 'column-stretch-start-nowrap-0',
+    style: { width: '100%', height: '100%', overflow: 'hidden' },
+  },
+    header,
+    regForm,
+    content,
+  );
+}
+
+module.exports = BotPanel;