@yancyyu/openhermit 1.6.3 → 1.6.5

package/src/main/services/teams-mvp/TaskDispatchService.ts

@@ -0,0 +1,440 @@
+import type {
+  DiscoverableTeam,
+  DispatchMeta,
+  TaskBusConfig,
+  TaskDispatchPayload,
+  TaskStatusUpdate,
+} from '@shared/types/team';
+import type { TeamWorkspaceService, TeamManifest } from './TeamWorkspaceService';
+import type Redis from 'ioredis';
+
+const DISPATCH_RULES_DEFAULT = `When to dispatch a task to another team:
+- Task requires access to a different codebase/project
+- Task explicitly mentions another team's domain or ownership
+- Task is blocked by work owned by another team
+- Task requires expertise the current team doesn't have
+
+Do NOT dispatch:
+- Task is within current team's project scope
+- Task can be completed with available tools
+- Task is a small change (< estimated 5 min)`;
+
+export interface DispatchResult {
+  dispatchId: string;
+  status: DispatchMeta['status'];
+  targetTeam: string;
+  message: string;
+}
+
+export class TaskDispatchService {
+  private workspace: TeamWorkspaceService;
+  private config: TaskBusConfig | null = null;
+  private redis: Redis | null = null;
+  private redisSub: Redis | null = null;
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  private consumerTimers: ReturnType<typeof setInterval>[] = [];
+  private disposed = false;
+
+  constructor(workspace: TeamWorkspaceService) {
+    this.workspace = workspace;
+  }
+
+  get dispatchRulesText(): string {
+    return DISPATCH_RULES_DEFAULT;
+  }
+
+  async start(config?: TaskBusConfig): Promise<void> {
+    this.config = config ?? null;
+    if (config?.enabled && config.redis) {
+      await this.connectRedis();
+    }
+  }
+
+  dispose(): void {
+    this.disposed = true;
+    this.stopHeartbeat();
+    this.stopConsumers();
+    this.redis?.disconnect();
+    this.redisSub?.disconnect();
+    this.redis = null;
+    this.redisSub = null;
+  }
+
+  // ── Agent-facing ──────────────────────────────────────────────
+
+  async listTeams(): Promise<DiscoverableTeam[]> {
+    const teams: DiscoverableTeam[] = [];
+
+    // Local teams
+    const localTeams = await this.workspace.listTeams();
+    for (const team of localTeams) {
+      teams.push({
+        slug: team.slug,
+        displayName: team.displayName ?? team.slug,
+        location: 'local',
+        status: 'online',
+        collaboration: team.collaboration !== false,
+      });
+    }
+
+    // Remote teams (via Redis)
+    if (this.redis) {
+      try {
+        const now = Date.now();
+        const staleThreshold = 90_000; // 90s
+        const entries = await this.redis.zrange('task:teams', 0, -1, 'WITHSCORES');
+        const localSlugs = new Set(teams.map((t) => t.slug));
+        for (let i = 0; i < entries.length; i += 2) {
+          const slug = entries[i] as string;
+          const ts = Number(entries[i + 1]);
+          if (localSlugs.has(slug)) continue;
+          teams.push({
+            slug,
+            displayName: slug,
+            location: 'remote',
+            status: now - ts < staleThreshold ? 'online' : 'offline',
+            collaboration: true,
+          });
+        }
+      } catch {
+        // Redis read failure — return local teams only
+      }
+    }
+
+    return teams;
+  }
+
+  async dispatchTask(
+    fromTeam: string,
+    task: { subject: string; description?: string; prompt?: string },
+    targetTeam: string
+  ): Promise<DispatchResult> {
+    if (fromTeam === targetTeam) {
+      return {
+        dispatchId: '',
+        status: 'failed',
+        targetTeam,
+        message: 'Cannot dispatch to self — use native task tools instead.',
+      };
+    }
+
+    const dispatchId = crypto.randomUUID();
+    const dispatchMeta: DispatchMeta = {
+      dispatchId,
+      originTeam: fromTeam,
+      targetTeam,
+      status: 'dispatched',
+      dispatchedAt: new Date().toISOString(),
+    };
+
+    // Route: local or remote
+    const isLocal = await this.isLocalTeam(targetTeam);
+    if (isLocal) {
+      await this.handleLocalDispatch(dispatchMeta, task);
+    } else if (this.redis) {
+      await this.handleRemoteDispatch(dispatchMeta, task);
+    } else {
+      return {
+        dispatchId,
+        status: 'failed',
+        targetTeam,
+        message: 'Redis not configured — remote dispatch unavailable.',
+      };
+    }
+
+    return {
+      dispatchId,
+      status: 'dispatched',
+      targetTeam,
+      message: `Task dispatched to ${targetTeam}`,
+    };
+  }
+
+  async onTaskCompleted(teamSlug: string, taskId: string): Promise<void> {
+    const tasks = await this.workspace.readTasks(teamSlug);
+    const task = tasks.find((t) => t.id === taskId);
+    if (!task?.dispatchMeta) return;
+
+    const meta = task.dispatchMeta;
+    const update: TaskStatusUpdate = {
+      dispatchId: meta.dispatchId,
+      originTeam: meta.originTeam,
+      status: 'completed',
+      remoteTaskId: task.id,
+      timestamp: new Date().toISOString(),
+      result: task.result ?? undefined,
+    };
+
+    // Update local dispatchMeta
+    await this.workspace.patchTask(teamSlug, taskId, {
+      dispatchMeta: { ...meta, status: 'completed', completedAt: update.timestamp },
+    } as any);
+
+    // Notify origin team
+    if (this.redis) {
+      const channel = `task:status:${meta.originTeam}`;
+      await this.redis.publish(channel, JSON.stringify(update)).catch((err: Error) => {
+        console.error('[TaskDispatchService] status publish failed:', err.message);
+      });
+    }
+  }
+
+  // ── Local dispatch ────────────────────────────────────────────
+
+  private async isLocalTeam(teamSlug: string): Promise<boolean> {
+    try {
+      await this.workspace.readTeamManifest(teamSlug);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private async handleLocalDispatch(
+    dispatchMeta: DispatchMeta,
+    task: { subject: string; description?: string; prompt?: string }
+  ): Promise<void> {
+    const created = await this.workspace.createTask(dispatchMeta.targetTeam, {
+      title: task.subject,
+      description: task.description,
+    });
+    // Attach dispatchMeta after creation
+    await this.workspace.patchTask(dispatchMeta.targetTeam, created.id, {
+      dispatchMeta,
+    } as any);
+  }
+
+  // ── Remote dispatch (Redis) ───────────────────────────────────
+
+  private async connectRedis(): Promise<void> {
+    if (!this.config?.redis) return;
+    try {
+      const ioredis = await import('ioredis');
+      const { host, port, password, db } = this.config.redis;
+      const opts = { host, port, password: password || undefined, db: db ?? 0 };
+
+      this.redis = new ioredis.default(opts);
+      this.redisSub = new ioredis.default(opts);
+
+      this.redis.on('error', (err: Error) => {
+        console.error('[TaskDispatchService] Redis error:', err.message);
+      });
+
+      await this.redis.ping();
+
+      this.startHeartbeat();
+      this.startConsumers();
+      this.subscribeStatus();
+    } catch (err) {
+      console.error('[TaskDispatchService] Redis connect failed:', err);
+      this.redis = null;
+      this.redisSub = null;
+    }
+  }
+
+  private async handleRemoteDispatch(
+    dispatchMeta: DispatchMeta,
+    task: { subject: string; description?: string; prompt?: string }
+  ): Promise<void> {
+    const payload: TaskDispatchPayload = {
+      dispatchId: dispatchMeta.dispatchId,
+      originTeam: dispatchMeta.originTeam,
+      targetTeam: dispatchMeta.targetTeam,
+      task: {
+        subject: task.subject,
+        description: task.description,
+        prompt: task.prompt,
+      },
+      dispatchedAt: dispatchMeta.dispatchedAt,
+    };
+
+    const streamKey = `task:dispatch:${dispatchMeta.targetTeam}`;
+    await this.redis!.xadd(streamKey, '*', 'payload', JSON.stringify(payload));
+  }
+
+  // ── Heartbeat ─────────────────────────────────────────────────
+
+  private startHeartbeat(): void {
+    this.stopHeartbeat();
+    const beat = async () => {
+      if (!this.redis || this.disposed) return;
+      const now = Date.now();
+      const localTeams = await this.workspace.listTeams();
+      for (const team of localTeams) {
+        await this.redis.zadd('task:teams', now, team.slug).catch(() => {});
+      }
+    };
+    beat();
+    this.heartbeatTimer = setInterval(beat, 30_000);
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+
+  // ── Consumers (XREADGROUP) ────────────────────────────────────
+
+  private startConsumers(): void {
+    if (!this.redis || !this.redisSub) return;
+
+    const startForTeam = async (teamSlug: string) => {
+      const streamKey = `task:dispatch:${teamSlug}`;
+      const groupName = `hermit-${teamSlug}`;
+      const consumerId = `consumer-${process.pid}`;
+
+      // Create consumer group (MKSTREAM creates stream if missing)
+      try {
+        await this.redis!.xgroup('CREATE', streamKey, groupName, '0', 'MKSTREAM');
+      } catch {
+        // Group already exists — ignore
+      }
+
+      const poll = async () => {
+        if (this.disposed || !this.redisSub) return;
+        try {
+          const raw: unknown = await (this.redisSub as any).xreadgroup(
+            'GROUP',
+            groupName,
+            consumerId,
+            'BLOCK',
+            5000,
+            'COUNT',
+            1,
+            'STREAMS',
+            streamKey,
+            '>'
+          );
+          const results = raw as [string, [string, (string | Buffer)[]][]][] | null;
+
+          if (!results || results.length === 0) return;
+
+          for (const [, messages] of results) {
+            if (!Array.isArray(messages)) continue;
+            for (const [msgId, fields] of messages) {
+              await this.handleIncomingDispatch(teamSlug, msgId, fields, groupName);
+            }
+          }
+        } catch {
+          // Read error — will retry next poll
+        }
+      };
+
+      // Initial poll, then interval
+      poll();
+      const timer = setInterval(poll, 5000);
+      this.consumerTimers.push(timer);
+    };
+
+    // Start consumer for each local team
+    this.workspace.listTeams().then((teams) => {
+      for (const team of teams) {
+        startForTeam(team.slug);
+      }
+    });
+  }
+
+  private async handleIncomingDispatch(
+    teamSlug: string,
+    msgId: string,
+    fields: (string | Buffer)[],
+    groupName: string
+  ): Promise<void> {
+    try {
+      // fields is [key, value, key, value, ...]
+      const payloadStr = fields[1]?.toString();
+      if (!payloadStr) return;
+
+      const payload: TaskDispatchPayload = JSON.parse(payloadStr);
+
+      // Write task to board.json
+      const created = await this.workspace.createTask(teamSlug, {
+        title: payload.task.subject,
+        description: payload.task.description,
+      });
+
+      const dispatchMeta: DispatchMeta = {
+        dispatchId: payload.dispatchId,
+        originTeam: payload.originTeam,
+        targetTeam: payload.targetTeam,
+        status: 'received',
+        dispatchedAt: payload.dispatchedAt,
+        receivedAt: new Date().toISOString(),
+        remoteTaskId: created.id,
+      };
+
+      await this.workspace.patchTask(teamSlug, created.id, {
+        dispatchMeta,
+      } as any);
+
+      // Send ack
+      if (this.redis) {
+        const ackKey = `task:ack:${payload.dispatchId}`;
+        const ackPayload = JSON.stringify({
+          dispatchId: payload.dispatchId,
+          status: 'received',
+          remoteTaskId: created.id,
+          timestamp: new Date().toISOString(),
+        });
+        await this.redis.xadd(ackKey, '*', 'ack', ackPayload);
+        await this.redis.xack(`task:dispatch:${teamSlug}`, groupName, msgId);
+      }
+    } catch (err) {
+      console.error('[TaskDispatchService] handleIncomingDispatch error:', err);
+    }
+  }
+
+  private stopConsumers(): void {
+    for (const t of this.consumerTimers) clearInterval(t);
+    this.consumerTimers = [];
+  }
+
+  // ── Status subscribe ──────────────────────────────────────────
+
+  private subscribeStatus(): void {
+    if (!this.redisSub) return;
+
+    this.workspace.listTeams().then((teams) => {
+      for (const team of teams) {
+        const channel = `task:status:${team.slug}`;
+
+        this.redisSub!.subscribe(channel).catch((err: Error) => {
+          console.error('[TaskDispatchService] subscribe failed:', err.message);
+        });
+      }
+    });
+
+    this.redisSub.on('message', (channel: string, message: string) => {
+      // channel format: task:status:{teamSlug}
+      if (!channel.startsWith('task:status:')) return;
+
+      try {
+        const update: TaskStatusUpdate = JSON.parse(message);
+        const teamSlug = channel.replace('task:status:', '');
+
+        // Find shadow task (dispatched from this team) and update status
+        this.handleStatusSync(teamSlug, update);
+      } catch {
+        // Ignore malformed messages
+      }
+    });
+  }
+
+  private async handleStatusSync(teamSlug: string, update: TaskStatusUpdate): Promise<void> {
+    const tasks = await this.workspace.readTasks(teamSlug);
+    const shadowTask = tasks.find((t) => t.dispatchMeta?.dispatchId === update.dispatchId);
+    if (!shadowTask) return;
+
+    await this.workspace.patchTask(teamSlug, shadowTask.id, {
+      dispatchMeta: {
+        ...shadowTask.dispatchMeta!,
+        status: update.status,
+        completedAt:
+          update.status === 'completed' ? update.timestamp : shadowTask.dispatchMeta!.completedAt,
+        remoteTaskId: update.remoteTaskId ?? shadowTask.dispatchMeta!.remoteTaskId,
+      },
+    } as any);
+  }
+}

package/src/main/services/teams-mvp/TeamProvisioningService.ts

@@ -3,7 +3,7 @@
  *
  * 设计（v2）:
  *   - 一个 Team = 一个 cc-connect project
- *   - createTeam(): 本地建目录 + cc-connect 创建 project + 注入 MCP 配置
+ *   - createTeam(): 本地建目录 + cc-connect 创建 project + 注入 CLAUDE.md 指令
  *   - dispatchTask(): assignee 变化时通过 Bridge 推消息给目标团队的 agent
  */
 
@@ -25,12 +25,6 @@ import {
 
 const logger = createLogger('TeamProvisioningService');
 
-/** MCP server 地址，注入到 claudecode/qoder 配置 */
-const MCP_SERVER_URL = process.env.HERMIT_MCP_URL ?? 'http://127.0.0.1:5680/mcp';
-
-/** 支持自动注入 MCP 配置的 harness 类型 */
-const MCP_AUTO_INJECT_HARNESS = new Set(['claudecode', 'qoder']);
-
 export class TeamProvisioningService {
   private readonly workspace: TeamWorkspaceService;
 
@@ -50,7 +44,7 @@ export class TeamProvisioningService {
    * 创建团队：
    * 1. 本地建目录 + team.json
    * 2. 在 cc-connect 创建 project（bridge platform）
-   * 3. 如果 harness 支持，注入 MCP 配置到 workDir
+   * 3. 注入 CLAUDE.md 跨团队派发指令
    * 4. 触发 cc-connect restart 激活 project
    */
   async createTeam(
@@ -83,9 +77,7 @@ export class TeamProvisioningService {
       }
     }
 
-    if (MCP_AUTO_INJECT_HARNESS.has(manifest.harness)) {
-      await this.injectMcpConfig(manifest.workDir, slug);
-    }
+    await this.injectTeamInstructions(manifest.workDir, slug);
 
     return { slug, manifest };
   }
@@ -247,38 +239,49 @@ export class TeamProvisioningService {
   }
 
   // ===========================================================================
-  // MCP config injection
+  // CLAUDE.md instruction injection
   // ===========================================================================
 
-  /**
-   * 向 workDir 注入 MCP 配置，让 claude code / qoder 自动发现 hermit-tasks 工具。
-   * 写入 workDir/.claude/settings.json（claudecode）。
-   */
-  private async injectMcpConfig(workDir: string, teamSlug: string): Promise<void> {
-    const settingsPath = path.join(workDir, '.claude', 'settings.json');
-    try {
-      await fs.promises.mkdir(path.dirname(settingsPath), { recursive: true });
+  async injectTeamInstructions(workDir: string, teamSlug: string): Promise<void> {
+    const mdPath = path.join(workDir, 'CLAUDE.md');
+    const section = `
+
+## Cross-Team Task Dispatch (Hermit)
+
+You can dispatch tasks to other teams via the Hermit local API:
 
-      let existing: Record<string, unknown> = {};
+- **List available teams**: \`curl -s http://127.0.0.1:5680/api/cross-team/targets\`
+- **Dispatch a task**: \`curl -s -X POST http://127.0.0.1:5680/api/cross-team/send -H 'Content-Type: application/json' -d '{"fromTeam":"${teamSlug}","toTeam":"TARGET_TEAM","subject":"Task title","description":"Optional description"}'\`
+
+Current team slug: \`${teamSlug}\`
+
+When to dispatch:
+- Task requires access to a different codebase/project
+- Task explicitly mentions another team's domain
+- Task is blocked by work owned by another team
+
+Do NOT dispatch:
+- Task is within current team's project scope
+- Task can be completed with available tools
+`;
+
+    try {
+      let existing = '';
       try {
-        const raw = await fs.promises.readFile(settingsPath, 'utf8');
-        existing = JSON.parse(raw) as Record<string, unknown>;
+        existing = await fs.promises.readFile(mdPath, 'utf8');
       } catch {
-        // file doesn't exist yet, start fresh
+        // File doesn't exist yet
       }
 
-      const mcpServers = (existing.mcpServers as Record<string, unknown>) ?? {};
-      mcpServers['hermit-tasks'] = {
-        url: MCP_SERVER_URL,
-        env: { HERMIT_TEAM_SLUG: teamSlug },
-      };
+      if (existing.includes('Cross-Team Task Dispatch (Hermit)')) {
+        return;
+      }
 
-      const updated = { ...existing, mcpServers };
-      await fs.promises.writeFile(settingsPath, JSON.stringify(updated, null, 2), 'utf8');
-      logger.info(`injected MCP config → ${settingsPath}`);
+      await fs.promises.writeFile(mdPath, existing + section, 'utf8');
+      logger.info(`injected team instructions → ${mdPath}`);
     } catch (err) {
       logger.warn(
-        `MCP config injection failed (workDir=${workDir}): ${err instanceof Error ? err.message : String(err)}`
+        `Team instructions injection failed: ${err instanceof Error ? err.message : String(err)}`
       );
     }
   }

package/src/main/services/teams-mvp/TeamWorkspaceService.ts

@@ -111,6 +111,8 @@ export interface Task {
   createdAt: string;
   updatedAt: string;
   order: number;
+  /** Cross-team dispatch metadata */
+  dispatchMeta?: import('@shared/types/team').DispatchMeta;
 }
 
 // ---------------------------------------------------------------------------

package/src/renderer/components/settings/SettingsTabs.tsx

@@ -6,11 +6,11 @@ import {
   TooltipProvider,
   TooltipTrigger,
 } from '@renderer/components/ui/tooltip';
-import { Bot, Info, PlugZap, Settings, Wrench } from 'lucide-react';
+import { Bot, Info, PlugZap, Settings, Share2, Wrench } from 'lucide-react';
 
 import type { LucideIcon } from 'lucide-react';
 
-export type SettingsSection = 'general' | 'channels' | 'harness' | 'advanced';
+export type SettingsSection = 'general' | 'channels' | 'harness' | 'task-bus' | 'advanced';
 
 interface SettingsTabsProps {
   activeSection: SettingsSection;
@@ -44,6 +44,12 @@ const tabs: TabConfig[] = [
     icon: Bot,
     description: '管理 AI Agent 运行时（12 种）的 Provider 配置、API Key、端点和 CLI 安装状态。',
   },
+  {
+    id: 'task-bus',
+    label: '任务总线',
+    icon: Share2,
+    description: '配置 Redis 消息总线，实现跨主机的团队任务派发和状态同步。',
+  },
   {
     id: 'advanced',
     label: '高级',

package/src/renderer/components/settings/SettingsView.tsx

@@ -11,6 +11,7 @@ import { useShallow } from 'zustand/react/shallow';
 
 import { useSettingsConfig, useSettingsHandlers } from './hooks';
 import { AdvancedSection, GeneralSection, HarnessSection, PlatformsSection } from './sections';
+import { TaskBusSection } from './sections/TaskBusSection';
 import { type SettingsSection, SettingsTabs } from './SettingsTabs';
 
 export const SettingsView = (): React.JSX.Element | null => {
@@ -28,6 +29,7 @@ export const SettingsView = (): React.JSX.Element | null => {
       const nextSection: SettingsSection =
         pendingSettingsSection === 'channels' ||
         pendingSettingsSection === 'harness' ||
+        pendingSettingsSection === 'task-bus' ||
         pendingSettingsSection === 'advanced'
           ? pendingSettingsSection
           : 'general';
@@ -137,6 +139,8 @@ export const SettingsView = (): React.JSX.Element | null => {
 
           {activeSection === 'harness' && <HarnessSection />}
 
+          {activeSection === 'task-bus' && <TaskBusSection />}
+
           {activeSection === 'advanced' && (
             <AdvancedSection
               saving={saving}